@boatdev/sdk 1.9.1 → 1.9.3

package/dist/apis/BoatApi.js

@@ -46,7 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxesSortEnum = exports.ReposSortEnum = exports.ReadFileEncodingEnum = exports.ListSnapshotsSortEnum = exports.ListSandboxSnapshotsSortEnum = exports.EventsSortEnum = exports.DesktopOperationThemeEnum = exports.DesktopOperationVncEnum = exports.BoatApi = void 0;
+exports.SandboxesSortEnum = exports.ReposSortEnum = exports.ReadFileEncodingEnum = exports.ListSnapshotsSortEnum = exports.ListSandboxSnapshotsSortEnum = exports.EventsSortEnum = exports.DesktopOperationThemeEnum = exports.DesktopOperationVncEnum = exports.CommandLogsEncodingEnum = exports.CommandLogsStreamEnum = exports.BoatApi = void 0;
 const runtime = __importStar(require("../runtime"));
 const ActiveOrgResponse_1 = require("../models/ActiveOrgResponse");
 const ActiveOrgUpdateRequest_1 = require("../models/ActiveOrgUpdateRequest");
@@ -56,8 +56,13 @@ const ApiKeySecretResponse_1 = require("../models/ApiKeySecretResponse");
 const ApiKeyUsageResponse_1 = require("../models/ApiKeyUsageResponse");
 const ApiKeysResponse_1 = require("../models/ApiKeysResponse");
 const Command200Response_1 = require("../models/Command200Response");
+const CommandAttachFrame_1 = require("../models/CommandAttachFrame");
+const CommandInfoResponse_1 = require("../models/CommandInfoResponse");
+const CommandListResponse_1 = require("../models/CommandListResponse");
+const CommandLogsResponse_1 = require("../models/CommandLogsResponse");
 const CommandRequest_1 = require("../models/CommandRequest");
 const CommandStatusResponse_1 = require("../models/CommandStatusResponse");
+const CommandStopResponse_1 = require("../models/CommandStopResponse");
 const ConversationsResponse_1 = require("../models/ConversationsResponse");
 const CreateSandboxEnvironmentRequest_1 = require("../models/CreateSandboxEnvironmentRequest");
 const CreateSandboxRequest_1 = require("../models/CreateSandboxRequest");
@@ -88,6 +93,7 @@ const NamedSnapshotShareCreatedResponse_1 = require("../models/NamedSnapshotShar
 const NamedSnapshotShareListResponse_1 = require("../models/NamedSnapshotShareListResponse");
 const NamedSnapshotShareRevokedResponse_1 = require("../models/NamedSnapshotShareRevokedResponse");
 const OrgListResponse_1 = require("../models/OrgListResponse");
+const ProcessListResponse_1 = require("../models/ProcessListResponse");
 const PromptRequest_1 = require("../models/PromptRequest");
 const PromptResponse_1 = require("../models/PromptResponse");
 const PromptRunResponse_1 = require("../models/PromptRunResponse");
@@ -117,6 +123,9 @@ const SteerRequest_1 = require("../models/SteerRequest");
 const SteerResponse_1 = require("../models/SteerResponse");
 const StopOperationResponse_1 = require("../models/StopOperationResponse");
 const StopRequest_1 = require("../models/StopRequest");
+const TelemetryResponse_1 = require("../models/TelemetryResponse");
+const TelemetrySetRequest_1 = require("../models/TelemetrySetRequest");
+const TelemetrySetResponse_1 = require("../models/TelemetrySetResponse");
 const UpdateSandboxEnvironmentRequest_1 = require("../models/UpdateSandboxEnvironmentRequest");
 const UpdateSandboxRequest_1 = require("../models/UpdateSandboxRequest");
 const UpgradeSandboxEnvironmentRequest_1 = require("../models/UpgradeSandboxEnvironmentRequest");
@@ -307,6 +316,58 @@ 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) => (0, CommandAttachFrame_1.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
      */
@@ -339,7 +400,7 @@ 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) {
@@ -348,13 +409,125 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, Command200Response_1.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) => (0, CommandListResponse_1.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) => (0, CommandLogsResponse_1.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
      */
@@ -369,6 +542,12 @@ 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;
@@ -388,6 +567,7 @@ 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) {
@@ -396,6 +576,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, CommandStatusResponse_1.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) {
@@ -1036,6 +1217,44 @@ 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) => (0, TelemetryResponse_1.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
      */
@@ -1314,6 +1533,50 @@ 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) => (0, CommandInfoResponse_1.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
      */
@@ -1547,7 +1810,7 @@ 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) {
@@ -1556,7 +1819,7 @@ 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) {
@@ -1651,6 +1914,44 @@ 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) => (0, TelemetryResponse_1.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
      */
@@ -2125,6 +2426,48 @@ 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) => (0, ProcessListResponse_1.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
      */
@@ -2909,6 +3252,50 @@ 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: (0, TelemetrySetRequest_1.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) => (0, TelemetrySetResponse_1.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
      */
@@ -3095,6 +3482,52 @@ 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) => (0, CommandStopResponse_1.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
      */
@@ -3466,6 +3899,20 @@ class BoatApi extends runtime.BaseAPI {
     }
 }
 exports.BoatApi = BoatApi;
+/**
+ * @export
+ */
+exports.CommandLogsStreamEnum = {
+    Stdout: 'stdout',
+    Stderr: 'stderr'
+};
+/**
+ * @export
+ */
+exports.CommandLogsEncodingEnum = {
+    Utf8: 'utf8',
+    Base64: 'base64'
+};
 /**
  * @export
  */