bdy 1.23.17-dev → 1.23.18-dev

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

@@ -8,21 +8,16 @@ const texts_1 = require("../../../texts");
 const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxEndpointGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_GET);
-commandSandboxEndpointGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxEndpointGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxEndpointGet);
 commandSandboxEndpointGet.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxEndpointGet.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxEndpointGet.argument('<endpoint-name>', texts_1.OPTION_SANDBOX_ENDPOINT_NAME_ARG);
 commandSandboxEndpointGet.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_ENDPOINT_GET}`);
 commandSandboxEndpointGet.action(async (identifier, endpointName, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const sandbox = await client.getSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const sandbox = await client.getSandbox(workspace, sandboxId);
     const endpoints = sandbox.endpoints || [];
     const endpoint = endpoints.find((ep) => ep.name === endpointName);
     if (!endpoint) {
@@ -46,18 +41,27 @@ commandSandboxEndpointGet.action(async (identifier, endpointName, options) => {
             data.push(['Whitelist', endpoint.whitelist?.join(', ')]);
         }
         if (endpoint.http) {
-            data.push(['HTTP2', endpoint.http.http2 ? output_1.default.getOkSign() : output_1.default.getCancelSign()]);
+            data.push([
+                'HTTP2',
+                endpoint.http.http2 ? output_1.default.getOkSign() : output_1.default.getCancelSign(),
+            ]);
             data.push([
                 'Verify certificate',
-                endpoint.http.verify_certificate ? output_1.default.getOkSign() : output_1.default.getCancelSign(),
+                endpoint.http.verify_certificate
+                    ? output_1.default.getOkSign()
+                    : output_1.default.getCancelSign(),
             ]);
             data.push([
                 'Compression',
-                endpoint.http.compression ? output_1.default.getOkSign() : output_1.default.getCancelSign(),
+                endpoint.http.compression
+                    ? output_1.default.getOkSign()
+                    : output_1.default.getCancelSign(),
             ]);
             data.push([
                 'Log requests',
-                endpoint.http.log_requests ? output_1.default.getOkSign() : output_1.default.getCancelSign(),
+                endpoint.http.log_requests
+                    ? output_1.default.getOkSign()
+                    : output_1.default.getCancelSign(),
             ]);
             data.push(['Auth type', endpoint.http.auth_type]);
             if (endpoint.http.serve_path) {

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

@@ -9,20 +9,15 @@ const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxEndpointList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_ENDPOINT_LIST);
 commandSandboxEndpointList.alias('ls');
-commandSandboxEndpointList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxEndpointList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxEndpointList);
 commandSandboxEndpointList.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxEndpointList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxEndpointList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_ENDPOINT_LIST}`);
 commandSandboxEndpointList.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const sandbox = await client.getSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const sandbox = await client.getSandbox(workspace, sandboxId);
     const endpoints = sandbox.endpoints || [];
     if (options.format === 'json') {
         output_1.default.json(endpoints);

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

@@ -9,8 +9,7 @@ const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxExecCommand = (0, utils_1.newCommand)('command', texts_1.DESC_COMMAND_SANDBOX_EXEC);
 commandSandboxExecCommand.alias('cmd');
-commandSandboxExecCommand.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxExecCommand.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxExecCommand);
 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);
@@ -19,14 +18,10 @@ commandSandboxExecCommand.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SAN
 commandSandboxExecCommand.action(async (identifier, command, options) => {
     output_1.default.handleSignals();
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
     const runtime = input_1.default.restApiSandboxExecRuntime(options.runtime);
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const cmdResult = await client.executeSandboxCommand(workspace, sandbox_id, {
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const cmdResult = await client.executeSandboxCommand(workspace, sandboxId, {
         command,
         runtime,
     });
@@ -35,7 +30,7 @@ commandSandboxExecCommand.action(async (identifier, command, options) => {
         output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_BACKGROUND)(identifier, cmdResult.id));
     }
     else {
-        const body = await client.streamSandboxCommandLogs(workspace, sandbox_id, cmdResult.id);
+        const body = await client.streamSandboxCommandLogs(workspace, sandboxId, cmdResult.id);
         body.on('data', (data) => {
             if (data) {
                 try {
@@ -52,7 +47,7 @@ commandSandboxExecCommand.action(async (identifier, command, options) => {
             }
         });
         body.on('close', async () => {
-            const cmdExit = await client.getSandboxCommand(workspace, sandbox_id, cmdResult.id);
+            const cmdExit = await client.getSandboxCommand(workspace, sandboxId, cmdResult.id);
             if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL) {
                 output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_SUCCESS)(identifier, cmdResult.id));
             }

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

@@ -8,25 +8,20 @@ const texts_1 = require("../../../texts");
 const input_1 = __importDefault(require("../../../input"));
 const output_1 = __importDefault(require("../../../output"));
 const commandSandboxExecKill = (0, utils_1.newCommand)('kill', texts_1.DESC_COMMAND_SANDBOX_EXEC_KILL);
-commandSandboxExecKill.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxExecKill.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxExecKill);
 commandSandboxExecKill.option('-f, --force', texts_1.OPTION_CONFIRM_FORCE);
 commandSandboxExecKill.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxExecKill.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
 commandSandboxExecKill.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_EXEC_KILL}`);
 commandSandboxExecKill.action(async (identifier, commandId, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
     const confirmed = options.force ||
         (await output_1.default.confirm((0, texts_1.OPTION_SANDBOX_COMMAND_KILL_CONFIRM)(identifier, commandId)));
     if (!confirmed)
         output_1.default.exitNormal();
-    await client.terminateSandboxCommand(workspace, sandbox_id, commandId);
+    await client.terminateSandboxCommand(workspace, sandboxId, commandId);
     output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_COMMAND_KILLED)(commandId));
 });
 exports.default = commandSandboxExecKill;

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

@@ -9,20 +9,15 @@ const input_1 = __importDefault(require("../../../input"));
 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('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxExecList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxExecList);
 commandSandboxExecList.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxExecList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxExecList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_EXEC_LIST}`);
 commandSandboxExecList.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const commandsResult = await client.listSandboxCommands(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const commandsResult = await client.listSandboxCommands(workspace, sandboxId);
     const commands = commandsResult.commands || [];
     commands.sort((a, b) => (b.id || '').localeCompare(a.id || ''));
     if (options.format === 'json') {

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

@@ -8,8 +8,7 @@ const texts_1 = require("../../../texts");
 const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxExecLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_EXEC_LOGS);
-commandSandboxExecLogs.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxExecLogs.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxExecLogs);
 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);
@@ -17,13 +16,9 @@ commandSandboxExecLogs.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBO
 commandSandboxExecLogs.action(async (identifier, commandId, options) => {
     output_1.default.handleSignals();
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const body = await client.streamSandboxCommandLogs(workspace, sandbox_id, commandId, !!options.wait);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const body = await client.streamSandboxCommandLogs(workspace, sandboxId, commandId, !!options.wait);
     body.on('data', (data) => {
         if (data) {
             try {
@@ -40,7 +35,7 @@ commandSandboxExecLogs.action(async (identifier, commandId, options) => {
         }
     });
     body.on('close', async () => {
-        const cmdExit = await client.getSandboxCommand(workspace, sandbox_id, commandId);
+        const cmdExit = await client.getSandboxCommand(workspace, sandboxId, commandId);
         if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL) {
             output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_SUCCESS)(identifier, commandId));
         }

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

@@ -8,21 +8,16 @@ const texts_1 = require("../../../texts");
 const input_1 = __importDefault(require("../../../input"));
 const output_1 = __importDefault(require("../../../output"));
 const commandSandboxExecStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_SANDBOX_EXEC_STATUS);
-commandSandboxExecStatus.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxExecStatus.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxExecStatus);
 commandSandboxExecStatus.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxExecStatus.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxExecStatus.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
 commandSandboxExecStatus.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_EXEC_STATUS}`);
 commandSandboxExecStatus.action(async (identifier, commandId, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const cmd = await client.getSandboxCommand(workspace, sandbox_id, commandId);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const cmd = await client.getSandboxCommand(workspace, sandboxId, commandId);
     if (options.format === 'json') {
         output_1.default.json(cmd);
     }

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

@@ -8,19 +8,14 @@ const texts_1 = require("../../texts");
 const output_1 = __importDefault(require("../../output"));
 const input_1 = __importDefault(require("../../input"));
 const commandSandboxGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_SANDBOX_GET);
-commandSandboxGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxGet);
 commandSandboxGet.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxGet.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxGet.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const sandbox = await client.getSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const sandbox = await client.getSandbox(workspace, sandboxId);
     if (options.format === 'json') {
         output_1.default.json(sandbox);
     }
@@ -44,7 +39,10 @@ commandSandboxGet.action(async (identifier, options) => {
                     ? `ssh ${sandbox.ssh_host} -p ${sandbox.ssh_port}`
                     : '-',
             ],
-            ['SSH via CLI', sandbox.identifier ? `bdy sb ssh ${sandbox.identifier}` : '-']
+            [
+                'SSH via CLI',
+                sandbox.identifier ? `bdy sb ssh ${sandbox.identifier}` : '-',
+            ],
         ];
         if (sandbox.endpoints && sandbox.endpoints.length > 0) {
             data.push([

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

@@ -9,14 +9,15 @@ const output_1 = __importDefault(require("../../output"));
 const input_1 = __importDefault(require("../../input"));
 const commandSandboxList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_LIST);
 commandSandboxList.alias('ls');
-commandSandboxList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxList);
 commandSandboxList.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxList.action(async (options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const result = await client.listSandboxes(workspace, project);
+    // One scope per call - the endpoint has no "every sandbox in the workspace"
+    // mode, so an unfiltered listing returns the workspace-scoped ones only.
+    const { project, environmentId } = await input_1.default.sandboxScope(client, workspace, options);
+    const result = await client.listSandboxes(workspace, project, environmentId);
     const sandboxes = result.sandboxes || [];
     if (options.format === 'json') {
         output_1.default.json(sandboxes);

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

@@ -9,18 +9,13 @@ const input_1 = __importDefault(require("../../input"));
 const output_1 = __importDefault(require("../../output"));
 const commandSandboxLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_LOGS);
 commandSandboxLogs.hideVersionUpdate = true;
-commandSandboxLogs.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxLogs.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxLogs);
 commandSandboxLogs.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxLogs.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const { boot_logs } = await client.getSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const { boot_logs } = await client.getSandbox(workspace, sandboxId);
     output_1.default.exitNormal((boot_logs || []).join('\n'));
 });
 exports.default = commandSandboxLogs;

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

@@ -8,24 +8,19 @@ const texts_1 = require("../../texts");
 const output_1 = __importDefault(require("../../output"));
 const input_1 = __importDefault(require("../../input"));
 const commandSandboxRestart = (0, utils_1.newCommand)('restart', texts_1.DESC_COMMAND_SANDBOX_RESTART);
-commandSandboxRestart.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxRestart.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxRestart);
 commandSandboxRestart.option('--wait [seconds]', texts_1.OPTION_SANDBOX_WAIT);
 commandSandboxRestart.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxRestart.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    await client.restartSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    await client.restartSandbox(workspace, sandboxId);
     if (options.wait) {
         output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_START);
         const timeout = parseInt(options.wait, 10) || 300;
         try {
-            const status = await client.sandboxWaitForRunning(workspace, sandbox_id, timeout);
+            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);
             }

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

@@ -9,8 +9,7 @@ const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxSnapshotCreate = (0, utils_1.newCommand)('create', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_CREATE);
 commandSandboxSnapshotCreate.alias('add');
-commandSandboxSnapshotCreate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxSnapshotCreate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxSnapshotCreate);
 commandSandboxSnapshotCreate.option('-n, --name <name>', texts_1.OPTION_SANDBOX_SNAPSHOT_NAME);
 commandSandboxSnapshotCreate.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxSnapshotCreate.option('--wait [seconds]', texts_1.OPTION_SANDBOX_WAIT);
@@ -18,24 +17,20 @@ commandSandboxSnapshotCreate.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_
 commandSandboxSnapshotCreate.action(async (identifier, options) => {
     const humanId = require('human-id').default;
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
     const defaultName = 'snapshot-' + humanId({ separator: '-', capitalize: false });
     const snapshotName = options.name || defaultName;
     const body = {
         name: snapshotName,
     };
-    const snapshot = await client.createSandboxSnapshot(workspace, sandbox_id, body);
+    const snapshot = await client.createSandboxSnapshot(workspace, sandboxId, body);
     const snapshotId = snapshot.id;
     if (options.wait) {
         output_1.default.normal(texts_1.TXT_SANDBOX_SNAPSHOT_WAITING);
         const timeout = parseInt(options.wait, 10) || 300;
         try {
-            const status = await client.sandboxWaitForSnapshot(workspace, sandbox_id, snapshotId, timeout);
+            const status = await client.sandboxWaitForSnapshot(workspace, sandboxId, snapshotId, timeout);
             if (status !== utils_1.SANDBOX_SNAPSHOT_STATUS.CREATED) {
                 output_1.default.exitError(texts_1.ERR_SANDBOX_SNAPSHOT_FAILED);
             }

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

@@ -9,21 +9,16 @@ const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxSnapshotDelete = (0, utils_1.newCommand)('delete', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_DELETE);
 commandSandboxSnapshotDelete.alias('rm');
-commandSandboxSnapshotDelete.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxSnapshotDelete.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxSnapshotDelete);
 commandSandboxSnapshotDelete.option('-f, --force', texts_1.OPTION_CONFIRM_FORCE);
 commandSandboxSnapshotDelete.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxSnapshotDelete.argument('<snapshot-name>', texts_1.OPTION_SANDBOX_SNAPSHOT_NAME_ARG);
 commandSandboxSnapshotDelete.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_SNAPSHOT_DELETE}`);
 commandSandboxSnapshotDelete.action(async (identifier, snapshotName, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const snapshotsResult = await client.listSandboxSnapshots(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const snapshotsResult = await client.listSandboxSnapshots(workspace, sandboxId);
     const snapshots = snapshotsResult.snapshots || [];
     const foundSnapshot = snapshots.find((s) => s.name === snapshotName);
     if (!foundSnapshot) {
@@ -33,7 +28,7 @@ commandSandboxSnapshotDelete.action(async (identifier, snapshotName, options) =>
         (await output_1.default.confirm((0, texts_1.TXT_SANDBOX_SNAPSHOT_DELETE_CONFIRM)(identifier, snapshotName)));
     if (!confirmed)
         output_1.default.exitNormal();
-    await client.deleteSandboxSnapshot(workspace, sandbox_id, foundSnapshot.id);
+    await client.deleteSandboxSnapshot(workspace, sandboxId, 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

@@ -8,27 +8,22 @@ const texts_1 = require("../../../texts");
 const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxSnapshotGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_GET);
-commandSandboxSnapshotGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxSnapshotGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxSnapshotGet);
 commandSandboxSnapshotGet.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxSnapshotGet.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxSnapshotGet.argument('<snapshot-name>', texts_1.OPTION_SANDBOX_SNAPSHOT_NAME_ARG);
 commandSandboxSnapshotGet.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_SNAPSHOT_GET}`);
 commandSandboxSnapshotGet.action(async (identifier, snapshotName, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const snapshotsResult = await client.listSandboxSnapshots(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const snapshotsResult = await client.listSandboxSnapshots(workspace, sandboxId);
     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, sandbox_id, foundSnapshot.id);
+    const snapshot = await client.getSandboxSnapshot(workspace, sandboxId, foundSnapshot.id);
     if (options.format === 'json') {
         output_1.default.json(snapshot);
     }

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

@@ -9,26 +9,24 @@ const output_1 = __importDefault(require("../../../output"));
 const input_1 = __importDefault(require("../../../input"));
 const commandSandboxSnapshotList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_SNAPSHOT_LIST);
 commandSandboxSnapshotList.alias('ls');
-commandSandboxSnapshotList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxSnapshotList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxSnapshotList);
 commandSandboxSnapshotList.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxSnapshotList.argument('[identifier]', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxSnapshotList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_SANDBOX_SNAPSHOT_LIST}`);
 commandSandboxSnapshotList.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
     let snapshots;
     if (identifier) {
-        const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-        if (!sandbox_id) {
-            output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-        }
-        const snapshotsResult = await client.listSandboxSnapshots(workspace, sandbox_id);
+        const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+        const snapshotsResult = await client.listSandboxSnapshots(workspace, sandboxId);
         snapshots = snapshotsResult.snapshots || [];
     }
     else {
-        const result = await client.listProjectSnapshots(workspace, project);
+        // Exact-scope listing, same as `sandbox list`: project_name, environment_id
+        // or neither for the workspace.
+        const { project, environmentId } = await input_1.default.sandboxScope(client, workspace, options);
+        const result = await client.listSnapshots(workspace, project, environmentId);
         snapshots = result.snapshots || [];
     }
     if (options.format === 'json') {

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

@@ -10,8 +10,7 @@ const input_1 = __importDefault(require("../../input"));
 const path_1 = require("path");
 const commandSandboxSsh = (0, utils_1.newCommand)('ssh', texts_1.DESC_COMMAND_SANDBOX_SSH);
 commandSandboxSsh.alias('connect');
-commandSandboxSsh.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxSsh.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxSsh);
 commandSandboxSsh.option('-i, --identity <path>', texts_1.OPTION_SANDBOX_SSH_IDENTITY);
 commandSandboxSsh.option('--print', texts_1.OPTION_SANDBOX_SSH_PRINT);
 commandSandboxSsh.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
@@ -51,23 +50,21 @@ const buildSshArgs = (host, port, identity, extra) => {
     args.push(host, ...extra);
     return args;
 };
-const quoteArg = (arg) => /[\s'"\\$`*?[\]{}();&|<>#~]/.test(arg) ? `'${arg.replace(/'/g, "'\\''")}'` : arg;
+const quoteArg = (arg) => /[\s'"\\$`*?[\]{}();&|<>#~]/.test(arg)
+    ? `'${arg.replace(/'/g, "'\\''")}'`
+    : arg;
 commandSandboxSsh.action(async (identifier, args, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    let sandbox = await client.getSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    let sandbox = await client.getSandbox(workspace, sandboxId);
     if (sandbox.status !== utils_1.SANDBOX_STATUS.RUNNING) {
         output_1.default.exitError((0, texts_1.ERR_SANDBOX_NOT_RUNNING)(identifier, sandbox.status || 'UNKNOWN'));
     }
     if (!sandbox.ssh_host || !sandbox.ssh_port) {
         // A sandbox that just became RUNNING may not have its forward port registered yet
         try {
-            sandbox = await client.sandboxWaitForPorts(workspace, sandbox_id, 30);
+            sandbox = await client.sandboxWaitForPorts(workspace, sandboxId, 30);
         }
         catch {
             output_1.default.exitError((0, texts_1.ERR_SANDBOX_SSH_NO_ACCESS)(identifier));

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

@@ -8,24 +8,19 @@ const texts_1 = require("../../texts");
 const output_1 = __importDefault(require("../../output"));
 const input_1 = __importDefault(require("../../input"));
 const commandSandboxStart = (0, utils_1.newCommand)('start', texts_1.DESC_COMMAND_SANDBOX_START);
-commandSandboxStart.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxStart.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxStart);
 commandSandboxStart.option('--wait [seconds]', texts_1.OPTION_SANDBOX_WAIT);
 commandSandboxStart.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxStart.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    await client.startSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    await client.startSandbox(workspace, sandboxId);
     if (options.wait) {
         output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_START);
         const timeout = parseInt(options.wait, 10) || 300;
         try {
-            const status = await client.sandboxWaitForRunning(workspace, sandbox_id, timeout);
+            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);
             }

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

@@ -8,19 +8,14 @@ const texts_1 = require("../../texts");
 const output_1 = __importDefault(require("../../output"));
 const input_1 = __importDefault(require("../../input"));
 const commandSandboxStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_SANDBOX_STATUS);
-commandSandboxStatus.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
-commandSandboxStatus.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+(0, utils_1.sandboxScopeOptions)(commandSandboxStatus);
 commandSandboxStatus.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandSandboxStatus.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
 commandSandboxStatus.action(async (identifier, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
-    const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
-    if (!sandbox_id) {
-        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
-    }
-    const sandbox = await client.getSandbox(workspace, sandbox_id);
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const sandbox = await client.getSandbox(workspace, sandboxId);
     if (options.format === 'json') {
         output_1.default.json(sandbox);
     }