bdy 1.16.12 → 1.16.15-dev

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

@@ -0,0 +1,147 @@
+"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',
+];
+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-command <commands...>', texts_1.OPTION_SANDBOX_INSTALL_COMMANDS);
+commandSandboxCreate.option('--run-command <command>', texts_1.OPTION_SANDBOX_RUN_COMMAND);
+commandSandboxCreate.option('--app-dir <directory>', texts_1.OPTION_SANDBOX_APP_DIR);
+commandSandboxCreate.option('--app-type <type>', texts_1.OPTION_SANDBOX_APP_TYPE);
+commandSandboxCreate.option('--tag <tags...>', texts_1.OPTION_SANDBOX_TAGS);
+commandSandboxCreate.option('--wait-for-running', texts_1.OPTION_SANDBOX_WAIT_RUNNING);
+commandSandboxCreate.option('--wait-for-running-timeout <seconds>', texts_1.OPTION_SANDBOX_WAIT_TIMEOUT, '300');
+commandSandboxCreate.option('--wait-for-configured', texts_1.OPTION_SANDBOX_WAIT_CONFIGURED);
+commandSandboxCreate.option('--wait-for-configured-timeout <seconds>', texts_1.OPTION_SANDBOX_WAIT_TIMEOUT, '300');
+commandSandboxCreate.option('--wait-for-app', texts_1.OPTION_SANDBOX_WAIT_APP);
+commandSandboxCreate.option('--wait-for-app-timeout <seconds>', texts_1.OPTION_SANDBOX_WAIT_TIMEOUT, '300');
+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);
+    if (options.resources && !VALID_RESOURCES.includes(options.resources)) {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_INVALID_RESOURCES)(options.resources));
+    }
+    const timestamp = Date.now().toString(36);
+    const baseName = (0, human_id_1.default)({ separator: '-', capitalize: false });
+    const defaultIdentifier = `${baseName}-${timestamp}`;
+    const body = {
+        name: options.name || baseName,
+        identifier: options.identifier || defaultIdentifier,
+    };
+    if (options.snapshot) {
+        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.installCommand) {
+        body.install_commands = options.installCommand.join('\n');
+    }
+    if (options.tags) {
+        body.tags = options.tags;
+    }
+    if (options.runCommand) {
+        body.run_command = options.runCommand;
+    }
+    if (options.appDir) {
+        body.app_dir = options.appDir;
+    }
+    if (options.appType) {
+        body.app_type = options.app_type;
+    }
+    output_1.default.normal((0, texts_1.TXT_SANDBOX_CREATING)(body.name, body.identifier));
+    const result = await client.createSandbox(workspace, project, body);
+    const sandboxId = result.id;
+    if (options.waitForRunning) {
+        output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_RUNNING);
+        const timeout = parseInt(options.waitForRunningTimeout, 10) || 300;
+        try {
+            const status = await client.sandboxWaitForRunning(workspace, sandboxId, timeout);
+            if (status !== utils_1.SANDBOX_STATUS.RUNNING) {
+                output_1.default.exitError(texts_1.ERR_SANDBOX_RUNNING_FAILED);
+            }
+        }
+        catch {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_RUNNING_TIMEOUT);
+        }
+    }
+    if (options.waitForConfigured) {
+        output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_SETUP);
+        const timeout = parseInt(options.waitForConfiguredTimeout, 10) || 300;
+        try {
+            const status = await client.sandboxWaitForConfigured(workspace, sandboxId, timeout);
+            if (status !== utils_1.SANDBOX_SETUP_STATUS.SUCCESS) {
+                output_1.default.exitError(texts_1.ERR_SANDBOX_SETUP_FAILED);
+            }
+        }
+        catch {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_SETUP_TIMEOUT);
+        }
+    }
+    if (options.waitForApp) {
+        output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_APP);
+        const timeout = parseInt(options.waitForAppTimeout, 10) || 300;
+        try {
+            const status = await client.sandboxWaitForApp(workspace, sandboxId, timeout);
+            if (status !== utils_1.SANDBOX_APP_STATUS.RUNNING) {
+                output_1.default.exitError(texts_1.ERR_SANDBOX_APP_FAILED);
+            }
+        }
+        catch {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_APP_TIMEOUT);
+        }
+    }
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CREATED)(result.identifier, result.html_url));
+});
+exports.default = commandSandboxCreate;

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

@@ -0,0 +1,34 @@
+"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);
+    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,40 @@
+"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 logger_1 = __importDefault(require("../../../logger"));
+const commandSandboxEndpointAdd = (0, utils_1.getBasicCommandSandboxEndpoint)('add', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_ADD);
+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);
+    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 || [];
+    const existing = endpoints.find((ep) => ep.name === options.name);
+    if (existing) {
+        output_1.default.exitError((0, texts_1.ERR_SANDBOX_ENDPOINT_EXISTS)(options.name));
+    }
+    const endpoint = input_1.default.prepareSandboxEndpoint(options);
+    logger_1.default.info(endpoint);
+    const updatedEndpoints = [...endpoints, endpoint];
+    const updatedSandbox = await client.updateSandbox(workspace, found.id, {
+        endpoints: updatedEndpoints,
+    });
+    const addedEndpoint = (updatedSandbox.endpoints || []).find((ep) => ep.name === options.name);
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_ENDPOINT_ADDED)(options.name, addedEndpoint.endpoint_url));
+});
+exports.default = commandSandboxEndpointAdd;

package/distTs/src/command/sandbox/endpoint/delete.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 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);
+    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 || [];
+    const endpointIndex = endpoints.findIndex((ep) => ep.name === endpointName);
+    if (endpointIndex === -1) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_ENDPOINT_NOT_FOUND);
+    }
+    const updatedEndpoints = endpoints.filter((ep) => ep.name !== endpointName);
+    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,101 @@
+"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);
+    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 || [];
+    const endpoint = endpoints.find((ep) => ep.name === endpointName);
+    if (!endpoint) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_ENDPOINT_NOT_FOUND);
+    }
+    const data = [
+        ['Property', 'Value'],
+        ['Name', endpoint.name || '-'],
+        ['Endpoint', endpoint.endpoint || '-'],
+        ['Type', endpoint.type || '-'],
+        ['Region', endpoint.region || '-'],
+        ['URL', endpoint.endpoint_url || '-'],
+        ['Timeout', endpoint.timeout?.toString() || '-'],
+    ];
+    if (endpoint.whitelist?.length) {
+        data.push(['Whitelist', endpoint.whitelist?.join(', ')]);
+    }
+    if (endpoint.http) {
+        data.push(['HTTP2', endpoint.http.http2 ? 'TRUE' : 'FALSE']);
+        data.push([
+            'Verify certificate',
+            endpoint.http.verify_certificate ? 'TRUE' : 'FALSE',
+        ]);
+        data.push(['Compression', endpoint.http.compression ? 'TRUE' : 'FALSE']);
+        data.push([
+            'Log requests',
+            endpoint.http.log_requests ? 'TRUE' : 'FALSE',
+        ]);
+        data.push(['Auth type', endpoint.http.auth_type]);
+        if (endpoint.http.serve_path) {
+            data.push(['Serve path', endpoint.http.serve_path]);
+        }
+        if (endpoint.http.circuit_breaker) {
+            data.push(['Circuit breaker', String(endpoint.http.circuit_breaker)]);
+        }
+        if (endpoint.http.whitelist_user_agents?.length) {
+            data.push([
+                'Whitelist user agents',
+                endpoint.http.whitelist_user_agents.join('\n'),
+            ]);
+        }
+        if (endpoint.http.rewrite_host_header) {
+            data.push(['Rewrite host header', endpoint.http.rewrite_host_header]);
+        }
+        let headers = Object.keys(endpoint.http.request_headers || {});
+        if (headers.length) {
+            data.push([
+                'Request headers',
+                headers
+                    .map((key) => `${key}: ${endpoint.http.request_headers[key]}`)
+                    .join('\n '),
+            ]);
+        }
+        headers = Object.keys(endpoint.http.response_headers || {});
+        if (headers.length) {
+            data.push([
+                'Request headers',
+                headers
+                    .map((key) => `${key}: ${endpoint.http.response_headers[key]}`)
+                    .join('\n '),
+            ]);
+        }
+    }
+    else if (endpoint.tls) {
+        data.push(['Terminate at', endpoint.tls.terminate_at]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxEndpointGet;

package/distTs/src/command/sandbox/endpoint/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 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);
+    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.exitError(texts_1.ERR_SANDBOX_ENDPOINTS_NOT_FOUND);
+    }
+    const data = [['Name', 'Endpoint', 'Type', 'Region', 'URL']];
+    for (const ep of endpoints) {
+        data.push([
+            ep.name || '-',
+            ep.endpoint || '-',
+            ep.type || '-',
+            ep.region || '-',
+            ep.endpoint_url || '-',
+        ]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxEndpointList;

package/distTs/src/command/sandbox/endpoint.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("./endpoint/list"));
+const get_1 = __importDefault(require("./endpoint/get"));
+const add_1 = __importDefault(require("./endpoint/add"));
+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(delete_1.default);
+exports.default = commandSandboxEndpoint;

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

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const texts_1 = require("../../../texts");
+const utils_1 = require("../../../utils");
+const output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxExecCommand = (0, utils_1.newCommand)('command', texts_1.DESC_COMMAND_SANDBOX_EXEC);
+commandSandboxExecCommand.alias('cmd');
+commandSandboxExecCommand.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxExecCommand.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxExecCommand.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxExecCommand.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxExecCommand.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxExecCommand.option('--runtime <runtime>', texts_1.OPTION_SANDBOX_RUNTIME);
+commandSandboxExecCommand.option('--wait', texts_1.OPTION_SANDBOX_WAIT);
+commandSandboxExecCommand.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxExecCommand.argument('<command>');
+commandSandboxExecCommand.action(async (identifier, command, options) => {
+    output_1.default.handleSignals();
+    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 runtime = input_1.default.restApiSandboxExecRuntime(options.runtime);
+    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 cmdResult = await client.executeSandboxCommand(workspace, found.id, {
+        command,
+        runtime,
+    });
+    output_1.default.gray((0, texts_1.TXT_SANDBOX_EXEC_ID)(cmdResult.id));
+    if (!options.wait) {
+        output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_BACKGROUND)(cmdResult.id));
+    }
+    else {
+        const body = await client.streamSandboxCommandLogs(workspace, found.id, cmdResult.id);
+        body.on('data', (data) => {
+            if (data) {
+                try {
+                    const json = JSON.parse(data);
+                    if (json.data)
+                        output_1.default.normal(json.data);
+                }
+                catch {
+                    // do nothing
+                }
+            }
+        });
+        body.on('close', async () => {
+            const cmdExit = await client.getSandboxCommand(workspace, found.id, cmdResult.id);
+            if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL) {
+                output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_SUCCESS)(cmdResult.id));
+            }
+            else if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.INPROGRESS) {
+                output_1.default.exitNormal((0, texts_1.TXT_SANDBOX_EXEC_INPROGRESS)(cmdResult.id));
+            }
+            else {
+                output_1.default.exitError((0, texts_1.TXT_SANDBOX_EXEC_FAILED)(cmdResult.id));
+            }
+        });
+    }
+});
+exports.default = commandSandboxExecCommand;

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

@@ -0,0 +1,34 @@
+"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 input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const output_1 = __importDefault(require("../../../output"));
+const commandSandboxExecKill = (0, utils_1.newCommand)('kill', texts_1.DESC_COMMAND_SANDBOX_EXEC_KILL);
+commandSandboxExecKill.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxExecKill.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxExecKill.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxExecKill.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxExecKill.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxExecKill.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxExecKill.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxExecKill.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);
+    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 = commandSandboxExecKill;

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

@@ -0,0 +1,53 @@
+"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 input_1 = __importDefault(require("../../../input"));
+const client_1 = __importDefault(require("../../../api/client"));
+const output_1 = __importDefault(require("../../../output"));
+const commandSandboxExecList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_EXEC_LIST);
+commandSandboxExecList.alias('ls');
+commandSandboxExecList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxExecList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxExecList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxExecList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxExecList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxExecList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxExecList.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);
+    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);
+    }
+    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 = commandSandboxExecList;

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

@@ -0,0 +1,59 @@
+"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 commandSandboxExecLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_EXEC_LOGS);
+commandSandboxExecLogs.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxExecLogs.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxExecLogs.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxExecLogs.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxExecLogs.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxExecLogs.option('--wait', texts_1.OPTION_SANDBOX_WAIT);
+commandSandboxExecLogs.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxExecLogs.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxExecLogs.action(async (identifier, commandId, options) => {
+    output_1.default.handleSignals();
+    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 || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    const body = await client.streamSandboxCommandLogs(workspace, found.id, commandId, !!options.wait);
+    body.on('data', (data) => {
+        if (data) {
+            try {
+                const json = JSON.parse(data);
+                if (json.data)
+                    output_1.default.normal(json.data);
+            }
+            catch {
+                // do nothing
+            }
+        }
+    });
+    body.on('close', async () => {
+        const cmdExit = await client.getSandboxCommand(workspace, found.id, commandId);
+        if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL) {
+            output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_SUCCESS)(commandId));
+        }
+        else if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.INPROGRESS) {
+            output_1.default.exitNormal((0, texts_1.TXT_SANDBOX_EXEC_INPROGRESS)(commandId));
+        }
+        else {
+            output_1.default.exitError((0, texts_1.TXT_SANDBOX_EXEC_FAILED)(commandId));
+        }
+    });
+});
+exports.default = commandSandboxExecLogs;