@vercel/sandbox 0.0.21 → 0.0.22

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @vercel/sandbox@0.0.21 build /home/runner/work/sandbox-sdk/sandbox-sdk/packages/sandbox
+> @vercel/sandbox@0.0.22 build /home/runner/work/sandbox-sdk/sandbox-sdk/packages/sandbox
 > tsc
 

package/.turbo/turbo-typecheck.log

@@ -1,4 +1,4 @@
 
-> @vercel/sandbox@0.0.21 typecheck /home/runner/work/sandbox-sdk/sandbox-sdk/packages/sandbox
+> @vercel/sandbox@0.0.22 typecheck /home/runner/work/sandbox-sdk/sandbox-sdk/packages/sandbox
 > tsc --noEmit
 

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @vercel/sandbox
 
+## 0.0.22
+
+### Patch Changes
+
+- add AbortSignal support in public interface ([#137](https://github.com/vercel/sandbox-sdk/pull/137))
+
+- add AbortSignal support to command.wait ([#136](https://github.com/vercel/sandbox-sdk/pull/136))
+
 ## 0.0.21
 
 ### Patch Changes

package/dist/api-client/api-client.d.ts

@@ -15,6 +15,7 @@ export declare class APIClient extends BaseClient {
     protected request(path: string, params?: RequestParams): Promise<Response>;
     getSandbox(params: {
         sandboxId: string;
+        signal?: AbortSignal;
     }): Promise<Parsed<{
         sandbox: {
             region: string;
@@ -58,6 +59,7 @@ export declare class APIClient extends BaseClient {
             vcpus: number;
         };
         runtime?: "node22" | "python3.13" | (string & {});
+        signal?: AbortSignal;
     }>): Promise<Parsed<{
         sandbox: {
             region: string;
@@ -89,6 +91,7 @@ export declare class APIClient extends BaseClient {
         args: string[];
         env: Record<string, string>;
         sudo: boolean;
+        signal?: AbortSignal;
     }): Promise<Parsed<{
         command: {
             name: string;
@@ -104,20 +107,24 @@ export declare class APIClient extends BaseClient {
         sandboxId: string;
         cmdId: string;
         wait: true;
+        signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof CommandFinishedResponse>>>;
     getCommand(params: {
         sandboxId: string;
         cmdId: string;
         wait?: boolean;
+        signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof CommandResponse>>>;
     mkDir(params: {
         sandboxId: string;
         path: string;
         cwd?: string;
+        signal?: AbortSignal;
     }): Promise<Parsed<{}>>;
     getFileWriter(params: {
         sandboxId: string;
         extractDir: string;
+        signal?: AbortSignal;
     }): {
         response: Promise<Response>;
         writer: FileWriter;
@@ -143,6 +150,7 @@ export declare class APIClient extends BaseClient {
          * @example 1540095775951
          */
         until?: number | Date;
+        signal?: AbortSignal;
     }): Promise<Parsed<{
         sandboxes: {
             region: string;
@@ -175,16 +183,19 @@ export declare class APIClient extends BaseClient {
             content: Buffer;
         }[];
         extractDir: string;
+        signal?: AbortSignal;
     }): Promise<void>;
     readFile(params: {
         sandboxId: string;
         path: string;
         cwd?: string;
+        signal?: AbortSignal;
     }): Promise<NodeJS.ReadableStream | null>;
     killCommand(params: {
         sandboxId: string;
         commandId: string;
         signal: number;
+        abortSignal?: AbortSignal;
     }): Promise<Parsed<{
         command: {
             name: string;
@@ -205,5 +216,6 @@ export declare class APIClient extends BaseClient {
     };
     stopSandbox(params: {
         sandboxId: string;
+        signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof SandboxResponse>>>;
 }

package/dist/api-client/api-client.js

@@ -53,7 +53,9 @@ class APIClient extends base_client_1.BaseClient {
         });
     }
     async getSandbox(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.SandboxAndRoutesResponse, await this.request(`/v1/sandboxes/${params.sandboxId}`));
+        return (0, base_client_1.parseOrThrow)(validators_1.SandboxAndRoutesResponse, await this.request(`/v1/sandboxes/${params.sandboxId}`, {
+            signal: params.signal,
+        }));
     }
     async createSandbox(params) {
         const privateParams = (0, types_1.getPrivateParams)(params);
@@ -68,6 +70,7 @@ class APIClient extends base_client_1.BaseClient {
                 runtime: params.runtime,
                 ...privateParams,
             }),
+            signal: params.signal,
         }));
     }
     async runCommand(params) {
@@ -80,17 +83,19 @@ class APIClient extends base_client_1.BaseClient {
                 env: params.env,
                 sudo: params.sudo,
             }),
+            signal: params.signal,
         }));
     }
     async getCommand(params) {
         return params.wait
-            ? (0, base_client_1.parseOrThrow)(validators_1.CommandFinishedResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { query: { wait: "true" } }))
-            : (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`));
+            ? (0, base_client_1.parseOrThrow)(validators_1.CommandFinishedResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { signal: params.signal, query: { wait: "true" } }))
+            : (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { signal: params.signal }));
     }
     async mkDir(params) {
         return (0, base_client_1.parseOrThrow)(validators_1.EmptyResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/fs/mkdir`, {
             method: "POST",
             body: JSON.stringify({ path: params.path, cwd: params.cwd }),
+            signal: params.signal,
         }));
     }
     getFileWriter(params) {
@@ -104,6 +109,7 @@ class APIClient extends base_client_1.BaseClient {
                         "x-cwd": params.extractDir,
                     },
                     body: await (0, consume_readable_1.consumeReadable)(writer.readable),
+                    signal: params.signal,
                 });
             })(),
             writer,
@@ -122,12 +128,14 @@ class APIClient extends base_client_1.BaseClient {
                     : params.until?.getTime(),
             },
             method: "GET",
+            signal: params.signal,
         }));
     }
     async writeFiles(params) {
         const { writer, response } = this.getFileWriter({
             sandboxId: params.sandboxId,
             extractDir: params.extractDir,
+            signal: params.signal,
         });
         for (const file of params.files) {
             await writer.addFile({
@@ -146,6 +154,7 @@ class APIClient extends base_client_1.BaseClient {
         const response = await this.request(`/v1/sandboxes/${params.sandboxId}/fs/read`, {
             method: "POST",
             body: JSON.stringify({ path: params.path, cwd: params.cwd }),
+            signal: params.signal,
         });
         if (response.status === 404) {
             return null;
@@ -159,6 +168,7 @@ class APIClient extends base_client_1.BaseClient {
         return (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/${params.commandId}/kill`, {
             method: "POST",
             body: JSON.stringify({ signal: params.signal }),
+            signal: params.abortSignal,
         }));
     }
     getLogs(params) {
@@ -200,7 +210,7 @@ class APIClient extends base_client_1.BaseClient {
     }
     async stopSandbox(params) {
         const url = `/v1/sandboxes/${params.sandboxId}/stop`;
-        return (0, base_client_1.parseOrThrow)(validators_1.SandboxResponse, await this.request(url, { method: "POST" }));
+        return (0, base_client_1.parseOrThrow)(validators_1.SandboxResponse, await this.request(url, { method: "POST", signal: params.signal }));
     }
 }
 exports.APIClient = APIClient;

package/dist/api-client/base-client.js

@@ -41,6 +41,7 @@ class BaseClient {
                 : opts?.headers,
             // @ts-expect-error Node.js' and undici's Agent have different types
             dispatcher: this.agent,
+            signal: opts?.signal,
         });
         if (this.debug) {
             const duration = Date.now() - start;

package/dist/command.d.ts

@@ -88,9 +88,13 @@ export declare class Command {
      * }
      * ```
      *
+     * @param params - Optional parameters.
+     * @param params.signal - An AbortSignal to cancel waiting.
      * @returns A {@link CommandFinished} instance with populated exit code.
      */
-    wait(): Promise<CommandFinished>;
+    wait(params?: {
+        signal?: AbortSignal;
+    }): Promise<CommandFinished>;
     /**
      * Get the output of `stdout`, `stderr`, or both as a string.
      *
@@ -98,35 +102,50 @@ export declare class Command {
      * not output valid Unicode.
      *
      * @param stream - The output stream to read: "stdout", "stderr", or "both".
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
      * @returns The output of the specified stream(s) as a string.
      */
-    output(stream?: "stdout" | "stderr" | "both"): Promise<string>;
+    output(stream?: "stdout" | "stderr" | "both", opts?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
     /**
      * Get the output of `stdout` as a string.
      *
      * NOTE: This may throw string conversion errors if the command does
      * not output valid Unicode.
      *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
      * @returns The standard output of the command.
      */
-    stdout(): Promise<string>;
+    stdout(opts?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
     /**
      * Get the output of `stderr` as a string.
      *
      * NOTE: This may throw string conversion errors if the command does
      * not output valid Unicode.
      *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
      * @returns The standard error output of the command.
      */
-    stderr(): Promise<string>;
+    stderr(opts?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
     /**
      * Kill a running command in a sandbox.
      *
-     * @param params - commandId and the signal to send the running process.
-     * Defaults to SIGTERM.
+     * @param signal - The signal to send the running process. Defaults to SIGTERM.
+     * @param opts - Optional parameters.
+     * @param opts.abortSignal - An AbortSignal to cancel the kill operation.
      * @returns Promise<void>.
      */
-    kill(signal?: Signal): Promise<void>;
+    kill(signal?: Signal, opts?: {
+        abortSignal?: AbortSignal;
+    }): Promise<void>;
 }
 /**
  * A command that has finished executing.

package/dist/command.js

@@ -82,13 +82,17 @@ class Command {
      * }
      * ```
      *
+     * @param params - Optional parameters.
+     * @param params.signal - An AbortSignal to cancel waiting.
      * @returns A {@link CommandFinished} instance with populated exit code.
      */
-    async wait() {
+    async wait(params) {
+        params?.signal?.throwIfAborted();
         const command = await this.client.getCommand({
             sandboxId: this.sandboxId,
             cmdId: this.cmd.id,
             wait: true,
+            signal: params?.signal,
         });
         return new CommandFinished({
             client: this.client,
@@ -104,11 +108,13 @@ class Command {
      * not output valid Unicode.
      *
      * @param stream - The output stream to read: "stdout", "stderr", or "both".
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
      * @returns The output of the specified stream(s) as a string.
      */
-    async output(stream = "both") {
+    async output(stream = "both", opts) {
         let data = "";
-        for await (const log of this.logs()) {
+        for await (const log of this.logs({ signal: opts?.signal })) {
             if (stream === "both" || log.stream === stream) {
                 data += log.data;
             }
@@ -121,10 +127,12 @@ class Command {
      * NOTE: This may throw string conversion errors if the command does
      * not output valid Unicode.
      *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
      * @returns The standard output of the command.
      */
-    async stdout() {
-        return this.output("stdout");
+    async stdout(opts) {
+        return this.output("stdout", opts);
     }
     /**
      * Get the output of `stderr` as a string.
@@ -132,23 +140,27 @@ class Command {
      * NOTE: This may throw string conversion errors if the command does
      * not output valid Unicode.
      *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
      * @returns The standard error output of the command.
      */
-    async stderr() {
-        return this.output("stderr");
+    async stderr(opts) {
+        return this.output("stderr", opts);
     }
     /**
      * Kill a running command in a sandbox.
      *
-     * @param params - commandId and the signal to send the running process.
-     * Defaults to SIGTERM.
+     * @param signal - The signal to send the running process. Defaults to SIGTERM.
+     * @param opts - Optional parameters.
+     * @param opts.abortSignal - An AbortSignal to cancel the kill operation.
      * @returns Promise<void>.
      */
-    async kill(signal) {
+    async kill(signal, opts) {
         await this.client.killCommand({
             sandboxId: this.sandboxId,
             commandId: this.cmd.id,
             signal: (0, resolveSignal_1.resolveSignal)(signal ?? "SIGTERM"),
+            abortSignal: opts?.abortSignal,
         });
     }
 }

package/dist/sandbox.d.ts

@@ -54,6 +54,10 @@ export interface CreateSandboxParams {
      * If not specified, the default runtime `node22` will be used.
      */
     runtime?: "node22" | "python3.13" | (string & {});
+    /**
+     * An AbortSignal to cancel sandbox creation.
+     */
+    signal?: AbortSignal;
 }
 /** @inline */
 interface GetSandboxParams {
@@ -61,6 +65,10 @@ interface GetSandboxParams {
      * Unique identifier of the sandbox.
      */
     sandboxId: string;
+    /**
+     * An AbortSignal to cancel the operation.
+     */
+    signal?: AbortSignal;
 }
 /** @inline */
 interface RunCommandParams {
@@ -96,6 +104,10 @@ interface RunCommandParams {
      * A `Writable` stream where `stderr` from the command will be piped
      */
     stderr?: Writable;
+    /**
+     * An AbortSignal to cancel the command execution
+     */
+    signal?: AbortSignal;
 }
 /**
  * A Sandbox is an isolated Linux MicroVM to run commands in.
@@ -181,17 +193,25 @@ export declare class Sandbox {
      * Get a previously run command by its ID.
      *
      * @param cmdId - ID of the command to retrieve
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A {@link Command} instance representing the command
      */
-    getCommand(cmdId: string): Promise<Command>;
+    getCommand(cmdId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<Command>;
     /**
      * Start executing a command in this sandbox.
      *
      * @param command - The command to execute.
      * @param args - Arguments to pass to the command.
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the command execution.
      * @returns A {@link CommandFinished} result once execution is done.
      */
-    runCommand(command: string, args?: string[]): Promise<CommandFinished>;
+    runCommand(command: string, args?: string[], opts?: {
+        signal?: AbortSignal;
+    }): Promise<CommandFinished>;
     /**
      * Start executing a command in detached mode.
      *
@@ -220,17 +240,25 @@ export declare class Sandbox {
      * Create a directory in the filesystem of this sandbox.
      *
      * @param path - Path of the directory to create
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      */
-    mkDir(path: string): Promise<void>;
+    mkDir(path: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
      * Read a file from the filesystem of this sandbox.
      *
      * @param file - File to read, with path and optional cwd
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A promise that resolves to a ReadableStream containing the file contents
      */
     readFile(file: {
         path: string;
         cwd?: string;
+    }, opts?: {
+        signal?: AbortSignal;
     }): Promise<NodeJS.ReadableStream | null>;
     /**
      * Write files to the filesystem of this sandbox.
@@ -238,12 +266,16 @@ export declare class Sandbox {
      * Writes files using the `vercel-sandbox` user.
      *
      * @param files - Array of files with path and stream/buffer contents
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A promise that resolves when the files are written
      */
     writeFiles(files: {
         path: string;
         content: Buffer;
-    }[]): Promise<void>;
+    }[], opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
      * Get the public domain of a port of this sandbox.
      *
@@ -255,8 +287,12 @@ export declare class Sandbox {
     /**
      * Stop the sandbox.
      *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A promise that resolves when the sandbox is stopped
      */
-    stop(): Promise<void>;
+    stop(opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
 }
 export {};

package/dist/sandbox.js

@@ -35,7 +35,10 @@ class Sandbox {
             teamId: credentials.teamId,
             token: credentials.token,
         });
-        return client.listSandboxes(params);
+        return client.listSandboxes({
+            ...params,
+            signal: params.signal,
+        });
     }
     /**
      * Create a new sandbox.
@@ -57,6 +60,7 @@ class Sandbox {
             timeout: params?.timeout,
             resources: params?.resources,
             runtime: params?.runtime,
+            signal: params?.signal,
             ...privateParams,
         });
         return new Sandbox({
@@ -79,6 +83,7 @@ class Sandbox {
         });
         const sandbox = await client.getSandbox({
             sandboxId: params.sandboxId,
+            signal: params.signal,
         });
         return new Sandbox({
             client,
@@ -102,12 +107,15 @@ class Sandbox {
      * Get a previously run command by its ID.
      *
      * @param cmdId - ID of the command to retrieve
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A {@link Command} instance representing the command
      */
-    async getCommand(cmdId) {
+    async getCommand(cmdId, opts) {
         const command = await this.client.getCommand({
             sandboxId: this.sandbox.id,
             cmdId,
+            signal: opts?.signal,
         });
         return new command_1.Command({
             client: this.client,
@@ -115,9 +123,9 @@ class Sandbox {
             cmd: command.json.command,
         });
     }
-    async runCommand(commandOrParams, args) {
+    async runCommand(commandOrParams, args, opts) {
         return typeof commandOrParams === "string"
-            ? this._runCommand({ cmd: commandOrParams, args })
+            ? this._runCommand({ cmd: commandOrParams, args, signal: opts?.signal })
             : this._runCommand(commandOrParams);
     }
     /**
@@ -135,6 +143,7 @@ class Sandbox {
             cwd: params.cwd,
             env: params.env ?? {},
             sudo: params.sudo ?? false,
+            signal: params.signal,
         });
         const command = new command_1.Command({
             client: this.client,
@@ -143,7 +152,7 @@ class Sandbox {
         });
         if (params.stdout || params.stderr) {
             (async () => {
-                for await (const log of command.logs()) {
+                for await (const log of command.logs({ signal: params.signal })) {
                     if (log.stream === "stdout") {
                         params.stdout?.write(log.data);
                     }
@@ -153,30 +162,36 @@ class Sandbox {
                 }
             })();
         }
-        return params.detached ? command : command.wait();
+        return params.detached ? command : command.wait({ signal: params.signal });
     }
     /**
      * Create a directory in the filesystem of this sandbox.
      *
      * @param path - Path of the directory to create
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      */
-    async mkDir(path) {
+    async mkDir(path, opts) {
         await this.client.mkDir({
             sandboxId: this.sandbox.id,
             path: path,
+            signal: opts?.signal,
         });
     }
     /**
      * Read a file from the filesystem of this sandbox.
      *
      * @param file - File to read, with path and optional cwd
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A promise that resolves to a ReadableStream containing the file contents
      */
-    async readFile(file) {
+    async readFile(file, opts) {
         return this.client.readFile({
             sandboxId: this.sandbox.id,
             path: file.path,
             cwd: file.cwd,
+            signal: opts?.signal,
         });
     }
     /**
@@ -185,14 +200,17 @@ class Sandbox {
      * Writes files using the `vercel-sandbox` user.
      *
      * @param files - Array of files with path and stream/buffer contents
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A promise that resolves when the files are written
      */
-    async writeFiles(files) {
+    async writeFiles(files, opts) {
         return this.client.writeFiles({
             sandboxId: this.sandbox.id,
             cwd: this.sandbox.cwd,
             extractDir: "/",
             files: files,
+            signal: opts?.signal,
         });
     }
     /**
@@ -214,11 +232,14 @@ class Sandbox {
     /**
      * Stop the sandbox.
      *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel the operation.
      * @returns A promise that resolves when the sandbox is stopped
      */
-    async stop() {
+    async stop(opts) {
         await this.client.stopSandbox({
             sandboxId: this.sandbox.id,
+            signal: opts?.signal,
         });
     }
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.0.21";
+export declare const VERSION = "0.0.22";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Autogenerated by inject-version.ts
-exports.VERSION = "0.0.21";
+exports.VERSION = "0.0.22";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/sandbox",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/api-client/api-client.ts

@@ -71,10 +71,12 @@ export class APIClient extends BaseClient {
     });
   }
 
-  async getSandbox(params: { sandboxId: string }) {
+  async getSandbox(params: { sandboxId: string; signal?: AbortSignal }) {
     return parseOrThrow(
       SandboxAndRoutesResponse,
-      await this.request(`/v1/sandboxes/${params.sandboxId}`),
+      await this.request(`/v1/sandboxes/${params.sandboxId}`, {
+        signal: params.signal,
+      }),
     );
   }
 
@@ -95,6 +97,7 @@ export class APIClient extends BaseClient {
       timeout?: number;
       resources?: { vcpus: number };
       runtime?: "node22" | "python3.13" | (string & {});
+      signal?: AbortSignal;
     }>,
   ) {
     const privateParams = getPrivateParams(params);
@@ -111,6 +114,7 @@ export class APIClient extends BaseClient {
           runtime: params.runtime,
           ...privateParams,
         }),
+        signal: params.signal,
       }),
     );
   }
@@ -122,6 +126,7 @@ export class APIClient extends BaseClient {
     args: string[];
     env: Record<string, string>;
     sudo: boolean;
+    signal?: AbortSignal;
   }) {
     return parseOrThrow(
       CommandResponse,
@@ -134,6 +139,7 @@ export class APIClient extends BaseClient {
           env: params.env,
           sudo: params.sudo,
         }),
+        signal: params.signal,
       }),
     );
   }
@@ -142,44 +148,58 @@ export class APIClient extends BaseClient {
     sandboxId: string;
     cmdId: string;
     wait: true;
+    signal?: AbortSignal;
   }): Promise<Parsed<z.infer<typeof CommandFinishedResponse>>>;
   async getCommand(params: {
     sandboxId: string;
     cmdId: string;
     wait?: boolean;
+    signal?: AbortSignal;
   }): Promise<Parsed<z.infer<typeof CommandResponse>>>;
   async getCommand(params: {
     sandboxId: string;
     cmdId: string;
     wait?: boolean;
+    signal?: AbortSignal;
   }) {
     return params.wait
       ? parseOrThrow(
           CommandFinishedResponse,
           await this.request(
             `/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`,
-            { query: { wait: "true" } },
+            { signal: params.signal, query: { wait: "true" } },
           ),
         )
       : parseOrThrow(
           CommandResponse,
           await this.request(
             `/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`,
+            { signal: params.signal },
           ),
         );
   }
 
-  async mkDir(params: { sandboxId: string; path: string; cwd?: string }) {
+  async mkDir(params: {
+    sandboxId: string;
+    path: string;
+    cwd?: string;
+    signal?: AbortSignal;
+  }) {
     return parseOrThrow(
       EmptyResponse,
       await this.request(`/v1/sandboxes/${params.sandboxId}/fs/mkdir`, {
         method: "POST",
         body: JSON.stringify({ path: params.path, cwd: params.cwd }),
+        signal: params.signal,
       }),
     );
   }
 
-  getFileWriter(params: { sandboxId: string; extractDir: string }) {
+  getFileWriter(params: {
+    sandboxId: string;
+    extractDir: string;
+    signal?: AbortSignal;
+  }) {
     const writer = new FileWriter();
     return {
       response: (async () => {
@@ -190,6 +210,7 @@ export class APIClient extends BaseClient {
             "x-cwd": params.extractDir,
           },
           body: await consumeReadable(writer.readable),
+          signal: params.signal,
         });
       })(),
       writer,
@@ -217,6 +238,7 @@ export class APIClient extends BaseClient {
      * @example 1540095775951
      */
     until?: number | Date;
+    signal?: AbortSignal;
   }) {
     return parseOrThrow(
       SandboxesResponse,
@@ -234,6 +256,7 @@ export class APIClient extends BaseClient {
               : params.until?.getTime(),
         },
         method: "GET",
+        signal: params.signal,
       }),
     );
   }
@@ -243,10 +266,12 @@ export class APIClient extends BaseClient {
     cwd: string;
     files: { path: string; content: Buffer }[];
     extractDir: string;
+    signal?: AbortSignal;
   }) {
     const { writer, response } = this.getFileWriter({
       sandboxId: params.sandboxId,
       extractDir: params.extractDir,
+      signal: params.signal,
     });
 
     for (const file of params.files) {
@@ -268,12 +293,14 @@ export class APIClient extends BaseClient {
     sandboxId: string;
     path: string;
     cwd?: string;
+    signal?: AbortSignal;
   }): Promise<NodeJS.ReadableStream | null> {
     const response = await this.request(
       `/v1/sandboxes/${params.sandboxId}/fs/read`,
       {
         method: "POST",
         body: JSON.stringify({ path: params.path, cwd: params.cwd }),
+        signal: params.signal,
       },
     );
 
@@ -292,6 +319,7 @@ export class APIClient extends BaseClient {
     sandboxId: string;
     commandId: string;
     signal: number;
+    abortSignal?: AbortSignal;
   }) {
     return parseOrThrow(
       CommandResponse,
@@ -300,6 +328,7 @@ export class APIClient extends BaseClient {
         {
           method: "POST",
           body: JSON.stringify({ signal: params.signal }),
+          signal: params.abortSignal,
         },
       ),
     );
@@ -356,11 +385,12 @@ export class APIClient extends BaseClient {
 
   async stopSandbox(params: {
     sandboxId: string;
+    signal?: AbortSignal;
   }): Promise<Parsed<z.infer<typeof SandboxResponse>>> {
     const url = `/v1/sandboxes/${params.sandboxId}/stop`;
     return parseOrThrow(
       SandboxResponse,
-      await this.request(url, { method: "POST" }),
+      await this.request(url, { method: "POST", signal: params.signal }),
     );
   }
 }

package/src/api-client/base-client.ts

@@ -55,6 +55,7 @@ export class BaseClient {
         : opts?.headers,
       // @ts-expect-error Node.js' and undici's Agent have different types
       dispatcher: this.agent,
+      signal: opts?.signal,
     });
 
     if (this.debug) {

package/src/command.ts

@@ -112,13 +112,18 @@ export class Command {
    * }
    * ```
    *
+   * @param params - Optional parameters.
+   * @param params.signal - An AbortSignal to cancel waiting.
    * @returns A {@link CommandFinished} instance with populated exit code.
    */
-  async wait() {
+  async wait(params?: { signal?: AbortSignal }) {
+    params?.signal?.throwIfAborted();
+
     const command = await this.client.getCommand({
       sandboxId: this.sandboxId,
       cmdId: this.cmd.id,
       wait: true,
+      signal: params?.signal,
     });
 
     return new CommandFinished({
@@ -136,11 +141,16 @@ export class Command {
    * not output valid Unicode.
    *
    * @param stream - The output stream to read: "stdout", "stderr", or "both".
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel output streaming.
    * @returns The output of the specified stream(s) as a string.
    */
-  async output(stream: "stdout" | "stderr" | "both" = "both") {
+  async output(
+    stream: "stdout" | "stderr" | "both" = "both",
+    opts?: { signal?: AbortSignal },
+  ) {
     let data = "";
-    for await (const log of this.logs()) {
+    for await (const log of this.logs({ signal: opts?.signal })) {
       if (stream === "both" || log.stream === stream) {
         data += log.data;
       }
@@ -154,10 +164,12 @@ export class Command {
    * NOTE: This may throw string conversion errors if the command does
    * not output valid Unicode.
    *
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel output streaming.
    * @returns The standard output of the command.
    */
-  async stdout() {
-    return this.output("stdout");
+  async stdout(opts?: { signal?: AbortSignal }) {
+    return this.output("stdout", opts);
   }
 
   /**
@@ -166,24 +178,28 @@ export class Command {
    * NOTE: This may throw string conversion errors if the command does
    * not output valid Unicode.
    *
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel output streaming.
    * @returns The standard error output of the command.
    */
-  async stderr() {
-    return this.output("stderr");
+  async stderr(opts?: { signal?: AbortSignal }) {
+    return this.output("stderr", opts);
   }
 
   /**
    * Kill a running command in a sandbox.
    *
-   * @param params - commandId and the signal to send the running process.
-   * Defaults to SIGTERM.
+   * @param signal - The signal to send the running process. Defaults to SIGTERM.
+   * @param opts - Optional parameters.
+   * @param opts.abortSignal - An AbortSignal to cancel the kill operation.
    * @returns Promise<void>.
    */
-  async kill(signal?: Signal) {
+  async kill(signal?: Signal, opts?: { abortSignal?: AbortSignal }) {
     await this.client.killCommand({
       sandboxId: this.sandboxId,
       commandId: this.cmd.id,
       signal: resolveSignal(signal ?? "SIGTERM"),
+      abortSignal: opts?.abortSignal,
     });
   }
 }

package/src/sandbox.ts

@@ -54,6 +54,11 @@ export interface CreateSandboxParams {
    * If not specified, the default runtime `node22` will be used.
    */
   runtime?: "node22" | "python3.13" | (string & {});
+
+  /**
+   * An AbortSignal to cancel sandbox creation.
+   */
+  signal?: AbortSignal;
 }
 
 /** @inline */
@@ -62,6 +67,10 @@ interface GetSandboxParams {
    * Unique identifier of the sandbox.
    */
   sandboxId: string;
+  /**
+   * An AbortSignal to cancel the operation.
+   */
+  signal?: AbortSignal;
 }
 
 /** @inline */
@@ -98,6 +107,10 @@ interface RunCommandParams {
    * A `Writable` stream where `stderr` from the command will be piped
    */
   stderr?: Writable;
+  /**
+   * An AbortSignal to cancel the command execution
+   */
+  signal?: AbortSignal;
 }
 
 /**
@@ -147,7 +160,10 @@ export class Sandbox {
       teamId: credentials.teamId,
       token: credentials.token,
     });
-    return client.listSandboxes(params);
+    return client.listSandboxes({
+      ...params,
+      signal: params.signal,
+    });
   }
 
   /**
@@ -175,6 +191,7 @@ export class Sandbox {
       timeout: params?.timeout,
       resources: params?.resources,
       runtime: params?.runtime,
+      signal: params?.signal,
       ...privateParams,
     });
 
@@ -202,6 +219,7 @@ export class Sandbox {
 
     const sandbox = await client.getSandbox({
       sandboxId: params.sandboxId,
+      signal: params.signal,
     });
 
     return new Sandbox({
@@ -236,12 +254,18 @@ export class Sandbox {
    * Get a previously run command by its ID.
    *
    * @param cmdId - ID of the command to retrieve
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel the operation.
    * @returns A {@link Command} instance representing the command
    */
-  async getCommand(cmdId: string): Promise<Command> {
+  async getCommand(
+    cmdId: string,
+    opts?: { signal?: AbortSignal },
+  ): Promise<Command> {
     const command = await this.client.getCommand({
       sandboxId: this.sandbox.id,
       cmdId,
+      signal: opts?.signal,
     });
 
     return new Command({
@@ -256,9 +280,15 @@ export class Sandbox {
    *
    * @param command - The command to execute.
    * @param args - Arguments to pass to the command.
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel the command execution.
    * @returns A {@link CommandFinished} result once execution is done.
    */
-  async runCommand(command: string, args?: string[]): Promise<CommandFinished>;
+  async runCommand(
+    command: string,
+    args?: string[],
+    opts?: { signal?: AbortSignal },
+  ): Promise<CommandFinished>;
 
   /**
    * Start executing a command in detached mode.
@@ -281,9 +311,10 @@ export class Sandbox {
   async runCommand(
     commandOrParams: string | RunCommandParams,
     args?: string[],
+    opts?: { signal?: AbortSignal },
   ): Promise<Command | CommandFinished> {
     return typeof commandOrParams === "string"
-      ? this._runCommand({ cmd: commandOrParams, args })
+      ? this._runCommand({ cmd: commandOrParams, args, signal: opts?.signal })
       : this._runCommand(commandOrParams);
   }
 
@@ -302,6 +333,7 @@ export class Sandbox {
       cwd: params.cwd,
       env: params.env ?? {},
       sudo: params.sudo ?? false,
+      signal: params.signal,
     });
 
     const command = new Command({
@@ -312,7 +344,7 @@ export class Sandbox {
 
     if (params.stdout || params.stderr) {
       (async () => {
-        for await (const log of command.logs()) {
+        for await (const log of command.logs({ signal: params.signal })) {
           if (log.stream === "stdout") {
             params.stdout?.write(log.data);
           } else if (log.stream === "stderr") {
@@ -322,18 +354,21 @@ export class Sandbox {
       })();
     }
 
-    return params.detached ? command : command.wait();
+    return params.detached ? command : command.wait({ signal: params.signal });
   }
 
   /**
    * Create a directory in the filesystem of this sandbox.
    *
    * @param path - Path of the directory to create
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel the operation.
    */
-  async mkDir(path: string): Promise<void> {
+  async mkDir(path: string, opts?: { signal?: AbortSignal }): Promise<void> {
     await this.client.mkDir({
       sandboxId: this.sandbox.id,
       path: path,
+      signal: opts?.signal,
     });
   }
 
@@ -341,13 +376,19 @@ export class Sandbox {
    * Read a file from the filesystem of this sandbox.
    *
    * @param file - File to read, with path and optional cwd
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel the operation.
    * @returns A promise that resolves to a ReadableStream containing the file contents
    */
-  async readFile(file: { path: string; cwd?: string }) {
+  async readFile(
+    file: { path: string; cwd?: string },
+    opts?: { signal?: AbortSignal },
+  ) {
     return this.client.readFile({
       sandboxId: this.sandbox.id,
       path: file.path,
       cwd: file.cwd,
+      signal: opts?.signal,
     });
   }
 
@@ -357,14 +398,20 @@ export class Sandbox {
    * Writes files using the `vercel-sandbox` user.
    *
    * @param files - Array of files with path and stream/buffer contents
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel the operation.
    * @returns A promise that resolves when the files are written
    */
-  async writeFiles(files: { path: string; content: Buffer }[]) {
+  async writeFiles(
+    files: { path: string; content: Buffer }[],
+    opts?: { signal?: AbortSignal },
+  ) {
     return this.client.writeFiles({
       sandboxId: this.sandbox.id,
       cwd: this.sandbox.cwd,
       extractDir: "/",
       files: files,
+      signal: opts?.signal,
     });
   }
 
@@ -387,11 +434,14 @@ export class Sandbox {
   /**
    * Stop the sandbox.
    *
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel the operation.
    * @returns A promise that resolves when the sandbox is stopped
    */
-  async stop() {
+  async stop(opts?: { signal?: AbortSignal }) {
     await this.client.stopSandbox({
       sandboxId: this.sandbox.id,
+      signal: opts?.signal,
     });
   }
 }

package/src/version.ts

@@ -1,2 +1,2 @@
 // Autogenerated by inject-version.ts
-export const VERSION = "0.0.21";
+export const VERSION = "0.0.22";