@archildata/api-types 0.0.13 → 0.0.15

package/index.d.ts

@@ -382,7 +382,7 @@ export interface paths {
         post?: never;
         /**
          * Delete a sandbox
-         * @description Permanently deletes a stopped, exited, or failed sandbox.
+         * @description Permanently deletes a stopped, exited, or failed sandbox and its backing disk. A sandbox with child forks cannot be deleted until those children are deleted, starting with the deepest ones.
          */
         delete: operations["deleteSandbox"];
         options?: never;
@@ -390,6 +390,35 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/sandboxes/{sid}/connections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create a direct sandbox connection
+         * @description Returns a short-lived WebSocket URL for an interactive shell in a
+         *     running sandbox. Connecting starts `/bin/sh` with a PTY. The connection
+         *     has no stored history or reconnect support.
+         *
+         *     The URL contains a signed token that expires at `expires_at`. An open
+         *     WebSocket can remain connected after the token expires. Clients send
+         *     input as `{"type":"input","data":"..."}` and terminal size changes as
+         *     `{"type":"resize","rows":24,"cols":80}`. The server returns terminal
+         *     output as text frames. Closing the WebSocket ends the shell. Pausing or
+         *     stopping the sandbox also closes the connection.
+         */
+        post: operations["createSandboxConnection"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/sandboxes/{sid}/execs": {
         parameters: {
             query?: never;
@@ -480,6 +509,31 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/sandboxes/{sid}/fork": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Fork a sandbox
+         * @description Checkpoints a running source sandbox and creates an isolated writable
+         *     disk branch. Forks from running or paused sources resume from the
+         *     source's CPU, memory, and disk state. Forks from stopped sources
+         *     cold-boot from the saved disk checkpoint. A running source is
+         *     resumed after its checkpoint; paused and stopped sources remain
+         *     inactive. Forked sandboxes may themselves be forked.
+         */
+        post: operations["forkSandbox"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/sandboxes/{sid}/resume": {
         parameters: {
             query?: never;
@@ -537,11 +591,11 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Stop a sandbox without saving memory
-         * @description Shuts down the VM without creating a memory snapshot. When the sandbox
-         *     is paused, this invalidates its committed snapshot and changes it to
-         *     `stopped`. The sandbox's identity, configuration, and disk state remain
-         *     available for a later cold start.
+         * Stop a sandbox
+         * @description Gracefully shuts down the guest, then checkpoints its disk before
+         *     entering `stopped`. The sandbox and any forks from it cold-boot from
+         *     disk state. Stopping a paused sandbox reuses its existing disk
+         *     checkpoint. In-flight execs receive the guest shutdown signal.
          */
         post: operations["stopSandbox"];
         delete?: never;
@@ -644,6 +698,17 @@ export interface components {
             port: number;
             hostname: string;
         };
+        SandboxConnection: {
+            /** Format: uri */
+            url: string;
+            /** Format: date-time */
+            expires_at: string;
+        };
+        ApiResponse_SandboxConnection: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["SandboxConnection"];
+        };
         SandboxPortMapping: {
             container_port: number;
             /** @enum {string} */
@@ -693,6 +758,10 @@ export interface components {
             max_ttl_seconds?: number;
             max_concurrent_execs?: number;
         };
+        ForkSandboxRequest: {
+            /** @description Name for the fork. A random word-list name is generated when omitted. */
+            name?: string;
+        };
         SandboxExecRequest: {
             /** @description Shell command, run via `/bin/sh -c` */
             command: string;
@@ -2291,7 +2360,42 @@ export interface operations {
             };
             401: components["responses"]["Unauthorized"];
             404: components["responses"]["NotFound"];
-            /** @description The sandbox must be stopped, exited, or failed before it can be deleted */
+            /** @description The sandbox must be stopped, exited, or failed and have no child forks. The error includes the number of child disks and up to 10 disk IDs that must be deleted first. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+        };
+    };
+    createSandboxConnection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description A short-lived direct connection URL */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_SandboxConnection"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            /** @description The sandbox is not running */
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -2483,6 +2587,50 @@ export interface operations {
             503: components["responses"]["RetryableUnavailable"];
         };
     };
+    forkSandbox: {
+        parameters: {
+            query?: {
+                /** @description Hold the request for a completed start or exec result */
+                wait?: components["parameters"]["Wait"];
+            };
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["ForkSandboxRequest"];
+            };
+        };
+        responses: {
+            /** @description The fork was created and its start is pending */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Sandbox"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            /** @description The source cannot be paused or its fork checkpoint is unavailable */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+            503: components["responses"]["RetryableUnavailable"];
+        };
+    };
     resumeSandbox: {
         parameters: {
             query?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archildata/api-types",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "API types for the Archil control plane",
   "type": "module",
   "types": "index.d.ts",