@boatdev/sdk 1.9.2 → 1.9.3

package/dist/esm/apis/BoatApi.js

@@ -20,8 +20,13 @@ import { ApiKeySecretResponseFromJSON, } from '../models/ApiKeySecretResponse';
 import { ApiKeyUsageResponseFromJSON, } from '../models/ApiKeyUsageResponse';
 import { ApiKeysResponseFromJSON, } from '../models/ApiKeysResponse';
 import { Command200ResponseFromJSON, } from '../models/Command200Response';
+import { CommandAttachFrameFromJSON, } from '../models/CommandAttachFrame';
+import { CommandInfoResponseFromJSON, } from '../models/CommandInfoResponse';
+import { CommandListResponseFromJSON, } from '../models/CommandListResponse';
+import { CommandLogsResponseFromJSON, } from '../models/CommandLogsResponse';
 import { CommandRequestToJSON, } from '../models/CommandRequest';
 import { CommandStatusResponseFromJSON, } from '../models/CommandStatusResponse';
+import { CommandStopResponseFromJSON, } from '../models/CommandStopResponse';
 import { ConversationsResponseFromJSON, } from '../models/ConversationsResponse';
 import { CreateSandboxEnvironmentRequestToJSON, } from '../models/CreateSandboxEnvironmentRequest';
 import { CreateSandboxRequestToJSON, } from '../models/CreateSandboxRequest';
@@ -52,6 +57,7 @@ import { NamedSnapshotShareCreatedResponseFromJSON, } from '../models/NamedSnaps
 import { NamedSnapshotShareListResponseFromJSON, } from '../models/NamedSnapshotShareListResponse';
 import { NamedSnapshotShareRevokedResponseFromJSON, } from '../models/NamedSnapshotShareRevokedResponse';
 import { OrgListResponseFromJSON, } from '../models/OrgListResponse';
+import { ProcessListResponseFromJSON, } from '../models/ProcessListResponse';
 import { PromptRequestToJSON, } from '../models/PromptRequest';
 import { PromptResponseFromJSON, } from '../models/PromptResponse';
 import { PromptRunResponseFromJSON, } from '../models/PromptRunResponse';
@@ -81,6 +87,9 @@ import { SteerRequestToJSON, } from '../models/SteerRequest';
 import { SteerResponseFromJSON, } from '../models/SteerResponse';
 import { StopOperationResponseFromJSON, } from '../models/StopOperationResponse';
 import { StopRequestToJSON, } from '../models/StopRequest';
+import { TelemetryResponseFromJSON, } from '../models/TelemetryResponse';
+import { TelemetrySetRequestToJSON, } from '../models/TelemetrySetRequest';
+import { TelemetrySetResponseFromJSON, } from '../models/TelemetrySetResponse';
 import { UpdateSandboxEnvironmentRequestToJSON, } from '../models/UpdateSandboxEnvironmentRequest';
 import { UpdateSandboxRequestToJSON, } from '../models/UpdateSandboxRequest';
 import { UpgradeSandboxEnvironmentRequestToJSON, } from '../models/UpgradeSandboxEnvironmentRequest';
@@ -271,6 +280,58 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.artifactRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for attachCommand without sending the request
+     */
+    async attachCommandRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling attachCommand().');
+        }
+        if (requestParameters['processId'] == null) {
+            throw new runtime.RequiredError('processId', 'Required parameter "processId" was null or undefined when calling attachCommand().');
+        }
+        const queryParameters = {};
+        if (requestParameters['stdoutOffset'] != null) {
+            queryParameters['stdoutOffset'] = requestParameters['stdoutOffset'];
+        }
+        if (requestParameters['stderrOffset'] != null) {
+            queryParameters['stderrOffset'] = requestParameters['stderrOffset'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/commands/{processId}/stream`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{processId}', encodeURIComponent(String(requestParameters['processId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * The output of a detached command as it is written, one JSON object per line, until the command ends. After 10 minutes the stream ends with a `reconnect` line: open it again with its offsets to continue with no gap. One open stream replaces polling. Needs the `exec` key scope.
+     * Attach to a detached command
+     */
+    async attachCommandRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.attachCommandRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandAttachFrameFromJSON(jsonValue));
+    }
+    /**
+     * The output of a detached command as it is written, one JSON object per line, until the command ends. After 10 minutes the stream ends with a `reconnect` line: open it again with its offsets to continue with no gap. One open stream replaces polling. Needs the `exec` key scope.
+     * Attach to a detached command
+     */
+    async attachCommand(requestParameters, initOverrides) {
+        const response = await this.attachCommandRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for command without sending the request
      */
@@ -303,7 +364,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox. Every command and its output are kept 90 days in the command history (`/sandboxes/{sandboxId}/command-history`), readable while the sandbox is stopped.
      * Execute a command in a sandbox
      */
     async commandRaw(requestParameters, initOverrides) {
@@ -312,13 +373,125 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => Command200ResponseFromJSON(jsonValue));
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox. Every command and its output are kept 90 days in the command history (`/sandboxes/{sandboxId}/command-history`), readable while the sandbox is stopped.
      * Execute a command in a sandbox
      */
     async command(requestParameters, initOverrides) {
         const response = await this.commandRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for commandHistory without sending the request
+     */
+    async commandHistoryRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling commandHistory().');
+        }
+        const queryParameters = {};
+        if (requestParameters['mode'] != null) {
+            queryParameters['mode'] = requestParameters['mode'];
+        }
+        if (requestParameters['q'] != null) {
+            queryParameters['q'] = requestParameters['q'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/command-history`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Every command run through `POST /sandboxes/{sandboxId}/commands` in the last 90 days, and every other process that wrote to its stdout/stderr in the last 72 hours (mode `process`), newest first. Works while the sandbox is stopped.
+     * List the command and process history
+     */
+    async commandHistoryRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.commandHistoryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandListResponseFromJSON(jsonValue));
+    }
+    /**
+     * Every command run through `POST /sandboxes/{sandboxId}/commands` in the last 90 days, and every other process that wrote to its stdout/stderr in the last 72 hours (mode `process`), newest first. Works while the sandbox is stopped.
+     * List the command and process history
+     */
+    async commandHistory(requestParameters, initOverrides) {
+        const response = await this.commandHistoryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for commandLogs without sending the request
+     */
+    async commandLogsRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling commandLogs().');
+        }
+        if (requestParameters['commandId'] == null) {
+            throw new runtime.RequiredError('commandId', 'Required parameter "commandId" was null or undefined when calling commandLogs().');
+        }
+        const queryParameters = {};
+        if (requestParameters['stream'] != null) {
+            queryParameters['stream'] = requestParameters['stream'];
+        }
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['encoding'] != null) {
+            queryParameters['encoding'] = requestParameters['encoding'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/command-history/{commandId}/logs`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{commandId}', encodeURIComponent(String(requestParameters['commandId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Reads stdout or stderr from a byte offset, at most 1 MiB per call. Read on with `nextOffset` until `done`. A running detached command gains output every 30 s; a streamed one every 2 s. Works while the sandbox is stopped.
+     * Read a command\'s stored output
+     */
+    async commandLogsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.commandLogsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandLogsResponseFromJSON(jsonValue));
+    }
+    /**
+     * Reads stdout or stderr from a byte offset, at most 1 MiB per call. Read on with `nextOffset` until `done`. A running detached command gains output every 30 s; a streamed one every 2 s. Works while the sandbox is stopped.
+     * Read a command\'s stored output
+     */
+    async commandLogs(requestParameters, initOverrides) {
+        const response = await this.commandLogsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for commandStatus without sending the request
      */
@@ -333,6 +506,12 @@ export class BoatApi extends runtime.BaseAPI {
         if (requestParameters['tailBytes'] != null) {
             queryParameters['tailBytes'] = requestParameters['tailBytes'];
         }
+        if (requestParameters['stdoutOffset'] != null) {
+            queryParameters['stdoutOffset'] = requestParameters['stdoutOffset'];
+        }
+        if (requestParameters['stderrOffset'] != null) {
+            queryParameters['stderrOffset'] = requestParameters['stderrOffset'];
+        }
         const headerParameters = {};
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
@@ -352,6 +531,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
+     * Without offsets, the answer holds the end of each log. With `stdoutOffset` or `stderrOffset`, it holds only the output written since those byte offsets, so each poll returns only new output. A sandbox agent too old for offsets answers 409 `agent_outdated`.
      * Get detached command status and logs
      */
     async commandStatusRaw(requestParameters, initOverrides) {
@@ -360,6 +540,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => CommandStatusResponseFromJSON(jsonValue));
     }
     /**
+     * Without offsets, the answer holds the end of each log. With `stdoutOffset` or `stderrOffset`, it holds only the output written since those byte offsets, so each poll returns only new output. A sandbox agent too old for offsets answers 409 `agent_outdated`.
      * Get detached command status and logs
      */
     async commandStatus(requestParameters, initOverrides) {
@@ -1000,6 +1181,44 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.deleteSnapshotRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for deleteTelemetry without sending the request
+     */
+    async deleteTelemetryRequestOpts() {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/telemetry`;
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Removes the export and its queued deliveries. Needs an API key with `account.admin`.
+     * Remove OpenTelemetry export
+     */
+    async deleteTelemetryRaw(initOverrides) {
+        const requestOptions = await this.deleteTelemetryRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TelemetryResponseFromJSON(jsonValue));
+    }
+    /**
+     * Removes the export and its queued deliveries. Needs an API key with `account.admin`.
+     * Remove OpenTelemetry export
+     */
+    async deleteTelemetry(initOverrides) {
+        const response = await this.deleteTelemetryRaw(initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for deleteWebhook without sending the request
      */
@@ -1278,6 +1497,50 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.getRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for getCommand without sending the request
+     */
+    async getCommandRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling getCommand().');
+        }
+        if (requestParameters['commandId'] == null) {
+            throw new runtime.RequiredError('commandId', 'Required parameter "commandId" was null or undefined when calling getCommand().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/command-history/{commandId}`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{commandId}', encodeURIComponent(String(requestParameters['commandId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Get one command from the history
+     */
+    async getCommandRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getCommandRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandInfoResponseFromJSON(jsonValue));
+    }
+    /**
+     * Get one command from the history
+     */
+    async getCommand(requestParameters, initOverrides) {
+        const response = await this.getCommandRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for getDataRetention without sending the request
      */
@@ -1511,7 +1774,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`).
+     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`). File responses accept a single `Range: bytes=` header and answer 206 with `Content-Range`, so large files can be downloaded in parts and resumed.
      * Download a file or folder from a snapshot
      */
     async getSnapshotFileRaw(requestParameters, initOverrides) {
@@ -1520,7 +1783,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.BlobApiResponse(response);
     }
     /**
-     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`).
+     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`). File responses accept a single `Range: bytes=` header and answer 206 with `Content-Range`, so large files can be downloaded in parts and resumed.
      * Download a file or folder from a snapshot
      */
     async getSnapshotFile(requestParameters, initOverrides) {
@@ -1615,6 +1878,44 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.getStopRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for getTelemetry without sending the request
+     */
+    async getTelemetryRequestOpts() {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/telemetry`;
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Returns the account\'s OpenTelemetry export, or `telemetry` null when none is set. Header values are never included. Needs an API key with `account.admin`.
+     * Get OpenTelemetry export
+     */
+    async getTelemetryRaw(initOverrides) {
+        const requestOptions = await this.getTelemetryRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TelemetryResponseFromJSON(jsonValue));
+    }
+    /**
+     * Returns the account\'s OpenTelemetry export, or `telemetry` null when none is set. Header values are never included. Needs an API key with `account.admin`.
+     * Get OpenTelemetry export
+     */
+    async getTelemetry(initOverrides) {
+        const response = await this.getTelemetryRaw(initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for getWebhook without sending the request
      */
@@ -2089,6 +2390,48 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.meRaw(initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for processes without sending the request
+     */
+    async processesRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling processes().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/processes`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * A running sandbox: every user-space process, read now, busiest first. A stopped sandbox: the last sample kept (`live: false`).
+     * List the processes in a sandbox
+     */
+    async processesRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.processesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProcessListResponseFromJSON(jsonValue));
+    }
+    /**
+     * A running sandbox: every user-space process, read now, busiest first. A stopped sandbox: the last sample kept (`live: false`).
+     * List the processes in a sandbox
+     */
+    async processes(requestParameters, initOverrides) {
+        const response = await this.processesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for prompt without sending the request
      */
@@ -2873,6 +3216,50 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.setEnvironmentVarRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for setTelemetry without sending the request
+     */
+    async setTelemetryRequestOpts(input) {
+        const requestParameters = runtime.unflattenBody(input, 'telemetrySetRequest', [], []);
+        if (requestParameters['telemetrySetRequest'] == null) {
+            throw new runtime.RequiredError('telemetrySetRequest', 'Required parameter "telemetrySetRequest" was null or undefined when calling setTelemetry().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/telemetry`;
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: TelemetrySetRequestToJSON(requestParameters['telemetrySetRequest']),
+        };
+    }
+    /**
+     * Sets the account\'s one OTLP/HTTP destination, or replaces it. Boat then sends one metrics export at once and returns the collector\'s answer in `test`.  Every 60 seconds Boat sends the sandbox and account gauges to `<endpoint>/v1/metrics`. Each sandbox lifecycle event goes to `<endpoint>/v1/logs`. The endpoint must use HTTPS on port 443 or 4318 and resolve only to public addresses. Needs an API key with `account.admin`.
+     * Set OpenTelemetry export
+     */
+    async setTelemetryRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.setTelemetryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => TelemetrySetResponseFromJSON(jsonValue));
+    }
+    /**
+     * Sets the account\'s one OTLP/HTTP destination, or replaces it. Boat then sends one metrics export at once and returns the collector\'s answer in `test`.  Every 60 seconds Boat sends the sandbox and account gauges to `<endpoint>/v1/metrics`. Each sandbox lifecycle event goes to `<endpoint>/v1/logs`. The endpoint must use HTTPS on port 443 or 4318 and resolve only to public addresses. Needs an API key with `account.admin`.
+     * Set OpenTelemetry export
+     */
+    async setTelemetry(requestParameters, initOverrides) {
+        const response = await this.setTelemetryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for share without sending the request
      */
@@ -3059,6 +3446,52 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.stopRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for stopCommand without sending the request
+     */
+    async stopCommandRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling stopCommand().');
+        }
+        if (requestParameters['processId'] == null) {
+            throw new runtime.RequiredError('processId', 'Required parameter "processId" was null or undefined when calling stopCommand().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/commands/{processId}`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{processId}', encodeURIComponent(String(requestParameters['processId'])));
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Sends SIGTERM to the command and every process it started, then SIGKILL to what is left after 5 s. Only a process started with `detached` can be stopped. The response carries the command\'s history record with its final state and output.
+     * Stop a detached command
+     */
+    async stopCommandRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.stopCommandRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandStopResponseFromJSON(jsonValue));
+    }
+    /**
+     * Sends SIGTERM to the command and every process it started, then SIGKILL to what is left after 5 s. Only a process started with `detached` can be stopped. The response carries the command\'s history record with its final state and output.
+     * Stop a detached command
+     */
+    async stopCommand(requestParameters, initOverrides) {
+        const response = await this.stopCommandRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for update without sending the request
      */
@@ -3429,6 +3862,20 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 }
+/**
+ * @export
+ */
+export const CommandLogsStreamEnum = {
+    Stdout: 'stdout',
+    Stderr: 'stderr'
+};
+/**
+ * @export
+ */
+export const CommandLogsEncodingEnum = {
+    Utf8: 'utf8',
+    Base64: 'base64'
+};
 /**
  * @export
  */