bdy 1.17.28-dev → 1.17.29-dev

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.17.28-dev",
+  "version": "1.17.29-dev",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {

package/distTs/src/api/client.js

@@ -623,6 +623,13 @@ class ApiClient {
             opts.package_version = version;
         return await this.getResourceByIdentifier(workspace, opts);
     }
+    async getSandboxByIdentifier(workspace, project, sandbox) {
+        const opts = {
+            project,
+            sandbox
+        };
+        return await this.getResourceByIdentifier(workspace, opts);
+    }
     async getPackageVersions(workspace, pkgId, page = 1, perPage = 10) {
         return await this.request({
             method: 'GET',

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

@@ -57,10 +57,8 @@ commandSandboxCp.addHelpText('after', texts_1.EXAMPLE_SANDBOX_CP);
 const upload = async (client, workspace, project, source, destination) => {
     const { sourcePath, sourceStats } = input_1.default.restApiSandboxUploadSourcePath(source);
     const { identifier, remotePath, isRemoteDir } = input_1.default.restApiSandboxUploadDestinationPath(destination);
-    const result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
     if (sourceStats.isFile()) {
@@ -68,7 +66,7 @@ const upload = async (client, workspace, project, source, destination) => {
         const name = (0, path_1.basename)(sourcePath);
         output_1.default.normal((0, texts_1.TXT_SANDBOX_CP_PROGRESS)(1, 1, name));
         const remoteFile = isRemoteDir ? (0, path_1.join)(remotePath, name) : remotePath;
-        await client.sandboxUploadFile(workspace, found.id, remoteFile, sourcePath);
+        await client.sandboxUploadFile(workspace, sandbox_id, remoteFile, sourcePath);
         output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(1));
     }
     else if (sourceStats.isDirectory()) {
@@ -90,7 +88,7 @@ const upload = async (client, workspace, project, source, destination) => {
             const remoteFile = (0, path_1.join)(baseRemoteDir, relativePath).replace(/\\/g, '/');
             output_1.default.clearPreviousLine();
             output_1.default.normal((0, texts_1.TXT_SANDBOX_CP_PROGRESS)(i + 1, files.length, relativePath));
-            await client.sandboxUploadFile(workspace, found.id, remoteFile, localFile);
+            await client.sandboxUploadFile(workspace, sandbox_id, remoteFile, localFile);
         }
         output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_CP_DONE)(files.length));
     }
@@ -101,14 +99,12 @@ const upload = async (client, workspace, project, source, destination) => {
 const download = async (client, workspace, project, source, destination, merge, replace) => {
     const { destPath, isDestPathDir } = input_1.default.restApiSandboxDownloadDestinationPath(destination, merge, replace);
     const { sourcePath, identifier } = input_1.default.restApiSandboxDownloadSourcePath(source);
-    const result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
     output_1.default.normal(texts_1.TXT_SANDBOX_CP_DOWNLOAD, false);
-    const { body, headers } = await client.sandboxDownloadFile(workspace, found.id, sourcePath);
+    const { body, headers } = await client.sandboxDownloadFile(workspace, sandbox_id, sourcePath);
     const isFile = headers['content-type'] === 'application/octet-stream';
     const name = (0, path_1.basename)(sourcePath);
     if (isFile) {

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

@@ -17,17 +17,15 @@ commandSandboxDestroy.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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
     const confirmed = options.force ||
         (await output_1.default.confirm((0, texts_1.TXT_SANDBOX_DESTROY_CONFIRM)(identifier)));
     if (!confirmed)
         output_1.default.exitNormal();
-    await client.deleteSandbox(workspace, found.id);
+    await client.deleteSandbox(workspace, sandbox_id);
     output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_DESTROYED)(identifier));
 });
 exports.default = commandSandboxDestroy;

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

@@ -15,13 +15,11 @@ commandSandboxEndpointAdd.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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const sandbox = await client.getSandbox(workspace, sandbox_id);
     const endpoints = sandbox.endpoints || [];
     const existing = endpoints.find((ep) => ep.name === options.name);
     if (existing) {
@@ -30,7 +28,7 @@ commandSandboxEndpointAdd.action(async (identifier, options) => {
     const endpoint = input_1.default.prepareSandboxEndpoint(options);
     logger_1.default.info(endpoint);
     const updatedEndpoints = [...endpoints, endpoint];
-    const updatedSandbox = await client.updateSandbox(workspace, found.id, {
+    const updatedSandbox = await client.updateSandbox(workspace, sandbox_id, {
         endpoints: updatedEndpoints,
     });
     const addedEndpoint = (updatedSandbox.endpoints || []).find((ep) => ep.name === options.name);

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

@@ -19,13 +19,11 @@ commandSandboxEndpointDelete.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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const sandbox = await client.getSandbox(workspace, sandbox_id);
     const endpoints = sandbox.endpoints || [];
     const endpointIndex = endpoints.findIndex((ep) => ep.name === endpointName);
     if (endpointIndex === -1) {
@@ -36,7 +34,7 @@ commandSandboxEndpointDelete.action(async (identifier, endpointName, options) =>
         (await output_1.default.confirm((0, texts_1.TXT_SANDBOX_ENDPOINT_DELETE_CONFIRM)(identifier, endpointName)));
     if (!confirmed)
         output_1.default.exitNormal();
-    await client.updateSandbox(workspace, found.id, {
+    await client.updateSandbox(workspace, sandbox_id, {
         endpoints: updatedEndpoints,
     });
     output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_ENDPOINT_DELETED)(endpointName));

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

@@ -17,13 +17,11 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const sandbox = await client.getSandbox(workspace, sandbox_id);
     const endpoints = sandbox.endpoints || [];
     const endpoint = endpoints.find((ep) => ep.name === endpointName);
     if (!endpoint) {

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

@@ -17,13 +17,11 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const sandbox = await client.getSandbox(workspace, sandbox_id);
     const endpoints = sandbox.endpoints || [];
     if (endpoints.length === 0) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_ENDPOINTS_NOT_FOUND);

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

@@ -22,13 +22,11 @@ commandSandboxExecCommand.action(async (identifier, command, options) => {
     const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
     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) {
+    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, found.id, {
+    const cmdResult = await client.executeSandboxCommand(workspace, sandbox_id, {
         command,
         runtime,
     });
@@ -37,7 +35,7 @@ commandSandboxExecCommand.action(async (identifier, command, options) => {
         output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_BACKGROUND)(cmdResult.id));
     }
     else {
-        const body = await client.streamSandboxCommandLogs(workspace, found.id, cmdResult.id);
+        const body = await client.streamSandboxCommandLogs(workspace, sandbox_id, cmdResult.id);
         body.on('data', (data) => {
             if (data) {
                 try {
@@ -54,7 +52,7 @@ commandSandboxExecCommand.action(async (identifier, command, options) => {
             }
         });
         body.on('close', async () => {
-            const cmdExit = await client.getSandboxCommand(workspace, found.id, cmdResult.id);
+            const cmdExit = await client.getSandboxCommand(workspace, sandbox_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));
             }

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

@@ -18,17 +18,15 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
     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, found.id, commandId);
+    await client.terminateSandboxCommand(workspace, sandbox_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

@@ -17,13 +17,11 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const commandsResult = await client.listSandboxCommands(workspace, sandbox_id);
     const commands = commandsResult.commands || [];
     if (commands.length === 0) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NO_COMMANDS);

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

@@ -19,13 +19,11 @@ commandSandboxExecLogs.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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id, commandId, !!options.wait);
+    const body = await client.streamSandboxCommandLogs(workspace, sandbox_id, commandId, !!options.wait);
     body.on('data', (data) => {
         if (data) {
             try {
@@ -42,7 +40,7 @@ commandSandboxExecLogs.action(async (identifier, commandId, options) => {
         }
     });
     body.on('close', async () => {
-        const cmdExit = await client.getSandboxCommand(workspace, found.id, commandId);
+        const cmdExit = await client.getSandboxCommand(workspace, sandbox_id, commandId);
         if (cmdExit.status === utils_1.SANDBOX_EXEC_STATUS.SUCCESSFUL) {
             output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_EXEC_SUCCESS)(commandId));
         }

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

@@ -17,13 +17,11 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id, commandId);
+    const cmd = await client.getSandboxCommand(workspace, sandbox_id, commandId);
     const data = [
         ['Property', 'Value'],
         ['Command ID', cmd.id || '-'],

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

@@ -15,13 +15,11 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const sandbox = await client.getSandbox(workspace, sandbox_id);
     const data = [
         ['Field', 'Value'],
         ['ID', sandbox.id || '-'],

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

@@ -16,18 +16,16 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    await client.restartSandbox(workspace, sandbox_id);
     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, found.id, timeout);
+            const status = await client.sandboxWaitForRunning(workspace, sandbox_id, 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

@@ -20,10 +20,8 @@ commandSandboxSnapshotCreate.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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
     const defaultName = 'snapshot-' + (0, human_id_1.default)({ separator: '-', capitalize: false });
@@ -31,13 +29,13 @@ commandSandboxSnapshotCreate.action(async (identifier, options) => {
     const body = {
         name: snapshotName,
     };
-    const snapshot = await client.createSandboxSnapshot(workspace, found.id, body);
+    const snapshot = await client.createSandboxSnapshot(workspace, sandbox_id, 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, found.id, snapshotId, timeout);
+            const status = await client.sandboxWaitForSnapshot(workspace, sandbox_id, 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

@@ -19,13 +19,11 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const snapshotsResult = await client.listSandboxSnapshots(workspace, sandbox_id);
     const snapshots = snapshotsResult.snapshots || [];
     const foundSnapshot = snapshots.find((s) => s.name === snapshotName);
     if (!foundSnapshot) {
@@ -35,7 +33,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, found.id, foundSnapshot.id);
+    await client.deleteSandboxSnapshot(workspace, sandbox_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

@@ -17,19 +17,17 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const snapshotsResult = await client.listSandboxSnapshots(workspace, sandbox_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 snapshot = await client.getSandboxSnapshot(workspace, sandbox_id, foundSnapshot.id);
     const data = [
         ['Field', 'Value'],
         ['Name', snapshot.name || '-'],

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

@@ -19,13 +19,11 @@ commandSandboxSnapshotList.action(async (identifier, options) => {
     const client = input_1.default.restApiTokenClient();
     let snapshots;
     if (identifier) {
-        const result = await client.listSandboxes(workspace, project);
-        const sandboxes = result.sandboxes || [];
-        const found = sandboxes.find((s) => s.identifier === identifier);
-        if (!found) {
+        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, found.id);
+        const snapshotsResult = await client.listSandboxSnapshots(workspace, sandbox_id);
         snapshots = snapshotsResult.snapshots || [];
     }
     else {

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

@@ -16,18 +16,16 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    await client.startSandbox(workspace, sandbox_id);
     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, found.id, timeout);
+            const status = await client.sandboxWaitForRunning(workspace, sandbox_id, 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

@@ -15,13 +15,11 @@ 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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    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, found.id);
+    const sandbox = await client.getSandbox(workspace, sandbox_id);
     output_1.default.table([
         ['Type', 'Status'],
         ['Status', sandbox.status || 'UNKNOWN'],

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

@@ -16,18 +16,16 @@ commandSandboxStop.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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
-    await client.stopSandbox(workspace, found.id);
+    await client.stopSandbox(workspace, sandbox_id);
     if (options.wait) {
         output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_STOP);
         const timeout = parseInt(options.wait, 10) || 300;
         try {
-            const status = await client.sandboxWaitForRunning(workspace, found.id, timeout);
+            const status = await client.sandboxWaitForRunning(workspace, sandbox_id, timeout);
             if (status !== utils_1.SANDBOX_STATUS.STOPPED) {
                 output_1.default.exitError(texts_1.ERR_SANDBOX_STOP_FAILED);
             }

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

@@ -21,22 +21,19 @@ commandSandboxUpdate.action(async (identifier, yamlFile, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const project = input_1.default.restApiProject(options.project);
     const client = input_1.default.restApiTokenClient();
-    let result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
-    const sandboxId = found.id;
     const body = {
         yaml: Buffer.from(yaml, 'utf8').toString('base64'),
     };
-    result = await client.updateSandboxByYaml(workspace, sandboxId, body);
+    const result = await client.updateSandboxByYaml(workspace, sandbox_id, body);
     if (options.waitForRunning) {
         output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_RUNNING);
         const timeout = parseInt(options.waitForRunning, 10) || 300;
         try {
-            const status = await client.sandboxWaitForRunning(workspace, sandboxId, timeout);
+            const status = await client.sandboxWaitForRunning(workspace, sandbox_id, timeout);
             if (status !== utils_1.SANDBOX_STATUS.RUNNING) {
                 output_1.default.exitError(texts_1.ERR_SANDBOX_RUNNING_FAILED);
             }
@@ -49,7 +46,7 @@ commandSandboxUpdate.action(async (identifier, yamlFile, options) => {
         output_1.default.normal(texts_1.TXT_SANDBOX_WAITING_SETUP);
         const timeout = parseInt(options.waitForConfigured, 10) || 300;
         try {
-            const status = await client.sandboxWaitForConfigured(workspace, sandboxId, timeout);
+            const status = await client.sandboxWaitForConfigured(workspace, sandbox_id, timeout);
             if (status !== utils_1.SANDBOX_SETUP_STATUS.SUCCESS) {
                 output_1.default.exitError(texts_1.ERR_SANDBOX_SETUP_FAILED);
             }

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

@@ -17,14 +17,11 @@ commandSandboxYaml.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 result = await client.listSandboxes(workspace, project);
-    const sandboxes = result.sandboxes || [];
-    const found = sandboxes.find((s) => s.identifier === identifier);
-    if (!found) {
+    const { sandbox_id } = await client.getSandboxByIdentifier(workspace, project, identifier);
+    if (!sandbox_id) {
         output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
     }
-    const sandboxId = found.id;
-    result = await client.getSandboxYaml(workspace, sandboxId);
+    const result = await client.getSandboxYaml(workspace, sandbox_id);
     output_1.default.exitNormal(Buffer.from(result.yaml, 'base64').toString('utf8'));
 });
 exports.default = commandSandboxYaml;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.17.28-dev",
+  "version": "1.17.29-dev",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {