@boatdev/sdk 1.9.6 → 1.9.8

package/.openapi-generator/FILES

@@ -46,6 +46,8 @@ docs/CreateSandboxRequest.md
 docs/CreateSandboxResponse.md
 docs/CreateScopedApiKey503Response.md
 docs/CreateScopedApiKeyRequest.md
+docs/CredentialAccount.md
+docs/CredentialAccountsResponse.md
 docs/CredentialId.md
 docs/CredentialProfile.md
 docs/CredentialProfileDeletedResponse.md
@@ -75,6 +77,7 @@ docs/HostPortResponse.md
 docs/LimitsFields.md
 docs/LimitsFieldsCurrentLimits.md
 docs/LimitsFieldsGiftLimit.md
+docs/LimitsFieldsMachineTypesInner.md
 docs/LimitsFieldsSandboxPlanTiersInner.md
 docs/LimitsFieldsStartLimits.md
 docs/LimitsFieldsStarts.md
@@ -124,6 +127,7 @@ docs/SandboxEnvironmentListResponse.md
 docs/SandboxEnvironmentResponse.md
 docs/SandboxEnvironmentVersionSummary.md
 docs/SandboxEvent.md
+docs/SandboxHydration.md
 docs/SandboxInfoResponse.md
 docs/SandboxListResponse.md
 docs/SandboxProcess.md
@@ -230,6 +234,8 @@ src/models/CreateSandboxRequest.ts
 src/models/CreateSandboxResponse.ts
 src/models/CreateScopedApiKey503Response.ts
 src/models/CreateScopedApiKeyRequest.ts
+src/models/CredentialAccount.ts
+src/models/CredentialAccountsResponse.ts
 src/models/CredentialId.ts
 src/models/CredentialProfile.ts
 src/models/CredentialProfileDeletedResponse.ts
@@ -259,6 +265,7 @@ src/models/HostPortResponse.ts
 src/models/LimitsFields.ts
 src/models/LimitsFieldsCurrentLimits.ts
 src/models/LimitsFieldsGiftLimit.ts
+src/models/LimitsFieldsMachineTypesInner.ts
 src/models/LimitsFieldsSandboxPlanTiersInner.ts
 src/models/LimitsFieldsStartLimits.ts
 src/models/LimitsFieldsStarts.ts
@@ -308,6 +315,7 @@ src/models/SandboxEnvironmentListResponse.ts
 src/models/SandboxEnvironmentResponse.ts
 src/models/SandboxEnvironmentVersionSummary.ts
 src/models/SandboxEvent.ts
+src/models/SandboxHydration.ts
 src/models/SandboxInfoResponse.ts
 src/models/SandboxListResponse.ts
 src/models/SandboxProcess.ts

package/README.md

@@ -10,8 +10,8 @@ npm install @boatdev/sdk
 
 ## Links
 
-- SDK docs: https://docs.boat.dev/sdks
-- API reference: https://docs.boat.dev/api/reference
+- SDK docs: https://docs.boat.dev/sdks/overview
+- API reference: https://docs.boat.dev/api/v1
 - Dashboard: https://boat.dev/dashboard
 - API keys: https://boat.dev/dashboard?tab=api-keys
 

package/dist/apis/BoatApi.d.ts

@@ -33,6 +33,7 @@ import { type CreateSandboxEnvironmentRequest } from '../models/CreateSandboxEnv
 import { type CreateSandboxRequest } from '../models/CreateSandboxRequest';
 import { type CreateSandboxResponse } from '../models/CreateSandboxResponse';
 import { type CreateScopedApiKeyRequest } from '../models/CreateScopedApiKeyRequest';
+import { type CredentialAccountsResponse } from '../models/CredentialAccountsResponse';
 import { type CredentialId } from '../models/CredentialId';
 import { type CredentialProfileDeletedResponse } from '../models/CredentialProfileDeletedResponse';
 import { type CredentialProfileListResponse } from '../models/CredentialProfileListResponse';
@@ -114,6 +115,11 @@ import { type WebhookListResponse } from '../models/WebhookListResponse';
 import { type WebhookResponse } from '../models/WebhookResponse';
 import { type WebhookSecretResponse } from '../models/WebhookSecretResponse';
 import { type WebhookUpdateRequest } from '../models/WebhookUpdateRequest';
+export interface AddCredentialAccountRequest {
+    profile: string;
+    credential: CredentialId;
+    setCredentialKeyRequest: SetCredentialKeyRequest;
+}
 export interface AddEnvironmentRepoOperationRequest {
     environmentId: string;
     addEnvironmentRepoRequest: AddEnvironmentRepoRequest;
@@ -191,6 +197,11 @@ export interface CreateUploadUrlRequest {
 export interface CreateWebhookRequest {
     webhookCreateRequest: WebhookCreateRequest;
 }
+export interface DeleteCredentialAccountRequest {
+    profile: string;
+    credential: CredentialId;
+    account: string;
+}
 export interface DeleteCredentialProfileRequest {
     profile: string;
 }
@@ -321,6 +332,10 @@ export interface LimitsRequest {
     xBoatOrg?: string;
     teamId?: string;
 }
+export interface ListCredentialAccountsRequest {
+    profile: string;
+    credential: CredentialId;
+}
 export interface ListSandboxSnapshotsRequest {
     sandboxId: string;
     limit?: number;
@@ -444,6 +459,11 @@ export interface StopCommandRequest {
     sandboxId: string;
     processId: number;
 }
+export interface SwitchCredentialAccountRequest {
+    profile: string;
+    credential: CredentialId;
+    account: string;
+}
 export interface UpdateRequest {
     sandboxId: string;
     updateSandboxRequest: UpdateSandboxRequest;
@@ -490,6 +510,20 @@ export interface WriteFileRequest {
  *
  */
 export declare class BoatApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for addCredentialAccount without sending the request
+     */
+    addCredentialAccountRequestOpts(input: AddCredentialAccountRequest | runtime.FlatBody<AddCredentialAccountRequest, 'setCredentialKeyRequest'>): Promise<runtime.RequestOpts>;
+    /**
+     * Adds an API key as another account of the credential, ready to switch to. The first key of a credential becomes the one in use. A sign-in returns `400 not_an_api_key`; add another sign-in with \"Add another account\" on the dashboard. Needs an API key with `account.admin`.
+     * Add another API key to a credential
+     */
+    addCredentialAccountRaw(requestParameters: AddCredentialAccountRequest | runtime.FlatBody<AddCredentialAccountRequest, 'setCredentialKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>>;
+    /**
+     * Adds an API key as another account of the credential, ready to switch to. The first key of a credential becomes the one in use. A sign-in returns `400 not_an_api_key`; add another sign-in with \"Add another account\" on the dashboard. Needs an API key with `account.admin`.
+     * Add another API key to a credential
+     */
+    addCredentialAccount(requestParameters: AddCredentialAccountRequest | runtime.FlatBody<AddCredentialAccountRequest, 'setCredentialKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;
     /**
      * Creates request options for addEnvironmentRepo without sending the request
      */
@@ -742,6 +776,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Create webhook
      */
     createWebhook(requestParameters: CreateWebhookRequest | runtime.FlatBody<CreateWebhookRequest, 'webhookCreateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WebhookSecretResponse>;
+    /**
+     * Creates request options for deleteCredentialAccount without sending the request
+     */
+    deleteCredentialAccountRequestOpts(requestParameters: DeleteCredentialAccountRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Deletes an account. For the account in use, the credential switches to another account first, or is removed when it was the last one. Needs an API key with `account.admin`.
+     * Forget an account of a credential
+     */
+    deleteCredentialAccountRaw(requestParameters: DeleteCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>>;
+    /**
+     * Deletes an account. For the account in use, the credential switches to another account first, or is removed when it was the last one. Needs an API key with `account.admin`.
+     * Forget an account of a credential
+     */
+    deleteCredentialAccount(requestParameters: DeleteCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;
     /**
      * Creates request options for deleteCredentialProfile without sending the request
      */
@@ -1228,6 +1276,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Get Boat limits
      */
     limits(requestParameters?: LimitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LimitsResponse>;
+    /**
+     * Creates request options for listCredentialAccounts without sending the request
+     */
+    listCredentialAccountsRequestOpts(requestParameters: ListCredentialAccountsRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
+     * List the accounts of a credential
+     */
+    listCredentialAccountsRaw(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>>;
+    /**
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
+     * List the accounts of a credential
+     */
+    listCredentialAccounts(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;
     /**
      * Creates request options for listCredentialProfiles without sending the request
      */
@@ -1716,6 +1778,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Stop a detached command
      */
     stopCommand(requestParameters: StopCommandRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CommandStopResponse>;
+    /**
+     * Creates request options for switchCredentialAccount without sending the request
+     */
+    switchCredentialAccountRequestOpts(requestParameters: SwitchCredentialAccountRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Makes this account the one in use; the previous one stays as another account. Switching to the account already in use changes nothing. Every sandbox that uses the profile gets it at once, running ones included, with no restart. Use it when one account runs out of credits. Needs an API key with `account.admin`.
+     * Switch a credential to another account
+     */
+    switchCredentialAccountRaw(requestParameters: SwitchCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>>;
+    /**
+     * Makes this account the one in use; the previous one stays as another account. Switching to the account already in use changes nothing. Every sandbox that uses the profile gets it at once, running ones included, with no restart. Use it when one account runs out of credits. Needs an API key with `account.admin`.
+     * Switch a credential to another account
+     */
+    switchCredentialAccount(requestParameters: SwitchCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;
     /**
      * Creates request options for update without sending the request
      */

package/dist/apis/BoatApi.js

@@ -71,6 +71,7 @@ const CreateSandboxEnvironmentRequest_1 = require("../models/CreateSandboxEnviro
 const CreateSandboxRequest_1 = require("../models/CreateSandboxRequest");
 const CreateSandboxResponse_1 = require("../models/CreateSandboxResponse");
 const CreateScopedApiKeyRequest_1 = require("../models/CreateScopedApiKeyRequest");
+const CredentialAccountsResponse_1 = require("../models/CredentialAccountsResponse");
 const CredentialProfileDeletedResponse_1 = require("../models/CredentialProfileDeletedResponse");
 const CredentialProfileListResponse_1 = require("../models/CredentialProfileListResponse");
 const CredentialProfileResponse_1 = require("../models/CredentialProfileResponse");
@@ -155,6 +156,58 @@ const WebhookUpdateRequest_1 = require("../models/WebhookUpdateRequest");
  *
  */
 class BoatApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for addCredentialAccount without sending the request
+     */
+    async addCredentialAccountRequestOpts(input) {
+        const requestParameters = runtime.unflattenBody(input, 'setCredentialKeyRequest', ['profile', 'credential'], []);
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError('profile', 'Required parameter "profile" was null or undefined when calling addCredentialAccount().');
+        }
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError('credential', 'Required parameter "credential" was null or undefined when calling addCredentialAccount().');
+        }
+        if (requestParameters['setCredentialKeyRequest'] == null) {
+            throw new runtime.RequiredError('setCredentialKeyRequest', 'Required parameter "setCredentialKeyRequest" was null or undefined when calling addCredentialAccount().');
+        }
+        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 = `/credential-profiles/{profile}/accounts/{credential}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, SetCredentialKeyRequest_1.SetCredentialKeyRequestToJSON)(requestParameters['setCredentialKeyRequest']),
+        };
+    }
+    /**
+     * Adds an API key as another account of the credential, ready to switch to. The first key of a credential becomes the one in use. A sign-in returns `400 not_an_api_key`; add another sign-in with \"Add another account\" on the dashboard. Needs an API key with `account.admin`.
+     * Add another API key to a credential
+     */
+    async addCredentialAccountRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.addCredentialAccountRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, CredentialAccountsResponse_1.CredentialAccountsResponseFromJSON)(jsonValue));
+    }
+    /**
+     * Adds an API key as another account of the credential, ready to switch to. The first key of a credential becomes the one in use. A sign-in returns `400 not_an_api_key`; add another sign-in with \"Add another account\" on the dashboard. Needs an API key with `account.admin`.
+     * Add another API key to a credential
+     */
+    async addCredentialAccount(requestParameters, initOverrides) {
+        const response = await this.addCredentialAccountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for addEnvironmentRepo without sending the request
      */
@@ -1010,6 +1063,56 @@ class BoatApi extends runtime.BaseAPI {
         const response = await this.createWebhookRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for deleteCredentialAccount without sending the request
+     */
+    async deleteCredentialAccountRequestOpts(requestParameters) {
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError('profile', 'Required parameter "profile" was null or undefined when calling deleteCredentialAccount().');
+        }
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError('credential', 'Required parameter "credential" was null or undefined when calling deleteCredentialAccount().');
+        }
+        if (requestParameters['account'] == null) {
+            throw new runtime.RequiredError('account', 'Required parameter "account" was null or undefined when calling deleteCredentialAccount().');
+        }
+        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 = `/credential-profiles/{profile}/accounts/{credential}/{account}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+        urlPath = urlPath.replace('{account}', encodeURIComponent(String(requestParameters['account'])));
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Deletes an account. For the account in use, the credential switches to another account first, or is removed when it was the last one. Needs an API key with `account.admin`.
+     * Forget an account of a credential
+     */
+    async deleteCredentialAccountRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.deleteCredentialAccountRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, CredentialAccountsResponse_1.CredentialAccountsResponseFromJSON)(jsonValue));
+    }
+    /**
+     * Deletes an account. For the account in use, the credential switches to another account first, or is removed when it was the last one. Needs an API key with `account.admin`.
+     * Forget an account of a credential
+     */
+    async deleteCredentialAccount(requestParameters, initOverrides) {
+        const response = await this.deleteCredentialAccountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for deleteCredentialProfile without sending the request
      */
@@ -2583,6 +2686,52 @@ class BoatApi extends runtime.BaseAPI {
         const response = await this.limitsRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for listCredentialAccounts without sending the request
+     */
+    async listCredentialAccountsRequestOpts(requestParameters) {
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError('profile', 'Required parameter "profile" was null or undefined when calling listCredentialAccounts().');
+        }
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError('credential', 'Required parameter "credential" was null or undefined when calling listCredentialAccounts().');
+        }
+        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 = `/credential-profiles/{profile}/accounts/{credential}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
+     * List the accounts of a credential
+     */
+    async listCredentialAccountsRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.listCredentialAccountsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, CredentialAccountsResponse_1.CredentialAccountsResponseFromJSON)(jsonValue));
+    }
+    /**
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
+     * List the accounts of a credential
+     */
+    async listCredentialAccounts(requestParameters, initOverrides) {
+        const response = await this.listCredentialAccountsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for listCredentialProfiles without sending the request
      */
@@ -4173,6 +4322,56 @@ class BoatApi extends runtime.BaseAPI {
         const response = await this.stopCommandRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for switchCredentialAccount without sending the request
+     */
+    async switchCredentialAccountRequestOpts(requestParameters) {
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError('profile', 'Required parameter "profile" was null or undefined when calling switchCredentialAccount().');
+        }
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError('credential', 'Required parameter "credential" was null or undefined when calling switchCredentialAccount().');
+        }
+        if (requestParameters['account'] == null) {
+            throw new runtime.RequiredError('account', 'Required parameter "account" was null or undefined when calling switchCredentialAccount().');
+        }
+        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 = `/credential-profiles/{profile}/accounts/{credential}/{account}/active`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+        urlPath = urlPath.replace('{account}', encodeURIComponent(String(requestParameters['account'])));
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Makes this account the one in use; the previous one stays as another account. Switching to the account already in use changes nothing. Every sandbox that uses the profile gets it at once, running ones included, with no restart. Use it when one account runs out of credits. Needs an API key with `account.admin`.
+     * Switch a credential to another account
+     */
+    async switchCredentialAccountRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.switchCredentialAccountRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, CredentialAccountsResponse_1.CredentialAccountsResponseFromJSON)(jsonValue));
+    }
+    /**
+     * Makes this account the one in use; the previous one stays as another account. Switching to the account already in use changes nothing. Every sandbox that uses the profile gets it at once, running ones included, with no restart. Use it when one account runs out of credits. Needs an API key with `account.admin`.
+     * Switch a credential to another account
+     */
+    async switchCredentialAccount(requestParameters, initOverrides) {
+        const response = await this.switchCredentialAccountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for update without sending the request
      */

package/dist/boat-helpers.d.ts

@@ -76,3 +76,26 @@ export type StreamCommandOptions = {
  * sent to a starting sandbox for up to 60 s instead of refusing it.
  */
 export declare function streamCommand(api: BoatApi, sandboxId: string, command: string, options?: StreamCommandOptions): AsyncGenerator<CommandFrame>;
+export type FollowCommandOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Yield a detached command's output from its start until it ends: `stdout`/`stderr`
+ * chunks (`frame.data`), then exactly one `exit` (`exitCode`, ...) or `error`
+ * (`message`). The server ends each connection after 10 minutes; this reconnects
+ * from the same offsets, with no gap and no repeat. A network cut is reconnected
+ * the same way for up to 60 s.
+ */
+export declare function followCommand(api: BoatApi, sandboxId: string, processId: number, options?: FollowCommandOptions): AsyncGenerator<CommandFrame>;
+export type RunCommandOptions = FollowCommandOptions & {
+    cwd?: string;
+};
+/**
+ * Run a command with no time limit and yield its output until it ends.
+ *
+ * The command runs detached, so it has no 600 s cap and survives a dropped
+ * connection. Frames: `{ type: 'started', processId }`, then the frames of
+ * `followCommand`. Stopping early leaves the command running: call
+ * `stopCommand({ sandboxId, processId })` to stop it.
+ */
+export declare function runCommand(api: BoatApi, sandboxId: string, command: string, options?: RunCommandOptions): AsyncGenerator<CommandFrame>;

package/dist/boat-helpers.js

@@ -12,6 +12,8 @@ exports.readText = readText;
 exports.writeText = writeText;
 exports.execCommand = execCommand;
 exports.streamCommand = streamCommand;
+exports.followCommand = followCommand;
+exports.runCommand = runCommand;
 const terminalPromptStatuses = new Set(['finished', 'failed']);
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -259,3 +261,98 @@ async function* streamCommand(api, sandboxId, command, options) {
         await delay(1000);
     }
 }
+// The server sends a heartbeat every 15 s, so 60 s of silence is a dead connection.
+const ATTACH_IDLE_MS = 60000;
+// After the first connection, a failed reconnect is tried again for this long.
+const ATTACH_RETRY_MS = 60000;
+function isNetworkError(e, signal) {
+    if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || e instanceof SyntaxError)
+        return false;
+    return !(e === null || e === void 0 ? void 0 : e.response);
+}
+/**
+ * Yield a detached command's output from its start until it ends: `stdout`/`stderr`
+ * chunks (`frame.data`), then exactly one `exit` (`exitCode`, ...) or `error`
+ * (`message`). The server ends each connection after 10 minutes; this reconnects
+ * from the same offsets, with no gap and no repeat. A network cut is reconnected
+ * the same way for up to 60 s.
+ */
+async function* followCommand(api, sandboxId, processId, options) {
+    var _a, _b, _c;
+    var _d, _e, _f, _g;
+    const offsets = { stdout: 0, stderr: 0 };
+    let connected = false;
+    // Set at the first failure after a good connection; any good connection clears it.
+    let failingSince;
+    for (;;) {
+        if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+            throw (_d = options.signal.reason) !== null && _d !== void 0 ? _d : new Error('followCommand aborted');
+        // One controller per connection: the caller's signal, or 60 s with no line.
+        const connection = new AbortController();
+        const abort = () => connection.abort();
+        (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.addEventListener('abort', abort);
+        let idle;
+        const touch = () => {
+            clearTimeout(idle);
+            idle = setTimeout(abort, ATTACH_IDLE_MS);
+        };
+        try {
+            touch();
+            const response = await api.attachCommandRaw({ sandboxId, processId, stdoutOffset: offsets.stdout, stderrOffset: offsets.stderr }, { signal: connection.signal });
+            connected = true;
+            failingSince = undefined;
+            for await (const frame of ndjsonFrames(response.raw)) {
+                touch();
+                if (frame.type === 'stdout' || frame.type === 'stderr') {
+                    offsets[frame.type] = (_e = frame.nextOffset) !== null && _e !== void 0 ? _e : offsets[frame.type];
+                    yield frame;
+                }
+                else if (frame.type === 'exit' || frame.type === 'error') {
+                    yield frame;
+                    return;
+                }
+                else {
+                    // attached, heartbeat, reconnect: ours to handle, never the caller's.
+                    offsets.stdout = (_f = frame.stdoutOffset) !== null && _f !== void 0 ? _f : offsets.stdout;
+                    offsets.stderr = (_g = frame.stderrOffset) !== null && _g !== void 0 ? _g : offsets.stderr;
+                }
+            }
+        }
+        catch (e) {
+            failingSince !== null && failingSince !== void 0 ? failingSince : (failingSince = Date.now());
+            if (!isNetworkError(e, options === null || options === void 0 ? void 0 : options.signal) || !connected || Date.now() - failingSince >= ATTACH_RETRY_MS)
+                throw e;
+            await delay(1000);
+        }
+        finally {
+            clearTimeout(idle);
+            (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.removeEventListener('abort', abort);
+        }
+    }
+}
+/**
+ * Run a command with no time limit and yield its output until it ends.
+ *
+ * The command runs detached, so it has no 600 s cap and survives a dropped
+ * connection. Frames: `{ type: 'started', processId }`, then the frames of
+ * `followCommand`. Stopping early leaves the command running: call
+ * `stopCommand({ sandboxId, processId })` to stop it.
+ */
+async function* runCommand(api, sandboxId, command, options) {
+    const deadline = Date.now() + STREAM_RETRY_MS;
+    let processId;
+    for (;;) {
+        try {
+            const started = await api.command({ sandboxId, commandRequest: { command, cwd: options === null || options === void 0 ? void 0 : options.cwd, detached: true } });
+            processId = started.processId;
+            break;
+        }
+        catch (e) {
+            if (Date.now() + 1000 >= deadline || !(await isRetryable(e)))
+                throw e;
+        }
+        await delay(1000);
+    }
+    yield { type: 'started', processId };
+    yield* followCommand(api, sandboxId, processId, options);
+}