@vercel/sandbox 0.0.21 → 0.0.23

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;
 }
 
 /**
@@ -129,10 +142,17 @@ export class Sandbox {
     return this.sandbox.status;
   }
 
+  /**
+   * The timeout of the sandbox in milliseconds.
+   */
+  public get timeout(): number {
+    return this.sandbox.timeout;
+  }
+
   /**
    * Internal metadata about this sandbox.
    */
-  private readonly sandbox: SandboxMetaData;
+  private sandbox: SandboxMetaData;
 
   /**
    * Allow to get a list of sandboxes for a team narrowed to the given params.
@@ -147,7 +167,10 @@ export class Sandbox {
       teamId: credentials.teamId,
       token: credentials.token,
     });
-    return client.listSandboxes(params);
+    return client.listSandboxes({
+      ...params,
+      signal: params.signal,
+    });
   }
 
   /**
@@ -175,6 +198,7 @@ export class Sandbox {
       timeout: params?.timeout,
       resources: params?.resources,
       runtime: params?.runtime,
+      signal: params?.signal,
       ...privateParams,
     });
 
@@ -202,6 +226,7 @@ export class Sandbox {
 
     const sandbox = await client.getSandbox({
       sandboxId: params.sandboxId,
+      signal: params.signal,
     });
 
     return new Sandbox({
@@ -236,12 +261,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 +287,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 +318,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 +340,7 @@ export class Sandbox {
       cwd: params.cwd,
       env: params.env ?? {},
       sudo: params.sudo ?? false,
+      signal: params.signal,
     });
 
     const command = new Command({
@@ -312,7 +351,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 +361,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 +383,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 +405,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 +441,39 @@ 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,
+    });
+  }
+
+  /**
+   * Extend the timeout of the sandbox by the specified duration.
+   *
+   * This allows you to extend the lifetime of a sandbox up until the maximum
+   * execution timeout for your plan.
+   *
+   * @param duration - The duration in milliseconds to extend the timeout by
+   * @param opts - Optional parameters.
+   * @param opts.signal - An AbortSignal to cancel the operation.
+   * @returns A promise that resolves when the timeout is extended
+   */
+  async extendTimeout(
+    duration: number,
+    opts?: { signal?: AbortSignal },
+  ): Promise<void> {
+    const response = await this.client.extendTimeout({
+      sandboxId: this.sandbox.id,
+      duration,
+      signal: opts?.signal,
     });
+
+    // Update the internal sandbox metadata with the new timeout value
+    this.sandbox = response.json.sandbox;
   }
 }

package/src/version.ts

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