@vercel/sandbox 1.0.3 → 1.1.0

package/src/sandbox.test.ts

@@ -1,34 +1,35 @@
-import { it, beforeEach, afterEach, expect } from "vitest";
+import { it, beforeEach, afterEach, expect, describe } from "vitest";
 import { consumeReadable } from "./utils/consume-readable";
 import { Sandbox } from "./sandbox";
 import { APIError } from "./api-client/api-error";
 import ms from "ms";
 
-const PORTS = [3000, 4000];
-let sandbox: Sandbox;
+describe.skipIf(process.env.RUN_INTEGRATION_TESTS !== "1")("Sandbox", () => {
+  const PORTS = [3000, 4000];
+  let sandbox: Sandbox;
 
-beforeEach(async () => {
-  sandbox = await Sandbox.create({ ports: PORTS });
-});
+  beforeEach(async () => {
+    sandbox = await Sandbox.create({ ports: PORTS });
+  });
 
-afterEach(async () => {
-  await sandbox.stop();
-});
+  afterEach(async () => {
+    await sandbox.stop();
+  });
 
-it("allows to write files and then read them", async () => {
-  await sandbox.writeFiles([
-    { path: "hello1.txt", content: Buffer.from("Hello 1") },
-    { path: "hello2.txt", content: Buffer.from("Hello 2") },
-  ]);
+  it("allows to write files and then read them", async () => {
+    await sandbox.writeFiles([
+      { path: "hello1.txt", content: Buffer.from("Hello 1") },
+      { path: "hello2.txt", content: Buffer.from("Hello 2") },
+    ]);
 
-  const content1 = await sandbox.readFile({ path: "hello1.txt" });
-  const content2 = await sandbox.readFile({ path: "hello2.txt" });
-  expect((await consumeReadable(content1!)).toString()).toBe("Hello 1");
-  expect((await consumeReadable(content2!)).toString()).toBe("Hello 2");
-});
+    const content1 = await sandbox.readFile({ path: "hello1.txt" });
+    const content2 = await sandbox.readFile({ path: "hello2.txt" });
+    expect((await consumeReadable(content1!)).toString()).toBe("Hello 1");
+    expect((await consumeReadable(content2!)).toString()).toBe("Hello 2");
+  });
 
-it("verifies port forwarding works correctly", async () => {
-  const serverScript = `
+  it("verifies port forwarding works correctly", async () => {
+    const serverScript = `
 const http = require('http');
 const ports = process.argv.slice(2);
 
@@ -44,48 +45,49 @@ for (const port of ports) {
 }
 `;
 
-  await sandbox.writeFiles([
-    { path: "server.js", content: Buffer.from(serverScript) },
-  ]);
+    await sandbox.writeFiles([
+      { path: "server.js", content: Buffer.from(serverScript) },
+    ]);
 
-  const server = await sandbox.runCommand({
-    cmd: "node",
-    args: ["server.js", ...PORTS.map(String)],
-    detached: true,
-    stdout: process.stdout,
-    stderr: process.stderr,
-  });
+    const server = await sandbox.runCommand({
+      cmd: "node",
+      args: ["server.js", ...PORTS.map(String)],
+      detached: true,
+      stdout: process.stdout,
+      stderr: process.stderr,
+    });
 
-  await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => setTimeout(resolve, 1000));
 
-  for (const port of PORTS) {
-    const response = await fetch(sandbox.domain(port));
-    const text = await response.text();
-    expect(text).toBe(`hello port ${port}`);
-  }
+    for (const port of PORTS) {
+      const response = await fetch(sandbox.domain(port));
+      const text = await response.text();
+      expect(text).toBe(`hello port ${port}`);
+    }
 
-  await server.kill();
-});
+    await server.kill();
+  });
 
-it("allows extending the sandbox timeout", async () => {
-  const originalTimeout = sandbox.timeout;
-  const extensionDuration = ms("5m");
+  it("allows extending the sandbox timeout", async () => {
+    const originalTimeout = sandbox.timeout;
+    const extensionDuration = ms("5m");
 
-  await sandbox.extendTimeout(extensionDuration);
-  expect(sandbox.timeout).toEqual(originalTimeout + extensionDuration);
-});
+    await sandbox.extendTimeout(extensionDuration);
+    expect(sandbox.timeout).toEqual(originalTimeout + extensionDuration);
+  });
 
-it("raises an error when the timeout cannot be updated", async () => {
-  try {
-    await sandbox.extendTimeout(ms("5d"));
-    expect.fail("Expected extendTimeout to throw an error");
-  } catch (error) {
-    expect(error).toBeInstanceOf(APIError);
-    expect(error).toMatchObject({
-      response: { status: 400 },
-      json: {
-        error: { code: "sandbox_timeout_invalid" },
-      },
-    });
-  }
+  it("raises an error when the timeout cannot be updated", async () => {
+    try {
+      await sandbox.extendTimeout(ms("5d"));
+      expect.fail("Expected extendTimeout to throw an error");
+    } catch (error) {
+      expect(error).toBeInstanceOf(APIError);
+      expect(error).toMatchObject({
+        response: { status: 400 },
+        json: {
+          error: { code: "sandbox_timeout_invalid" },
+        },
+      });
+    }
+  });
 });

package/src/sandbox.ts

@@ -4,6 +4,8 @@ import { APIClient } from "./api-client";
 import { Command, type CommandFinished } from "./command";
 import { type Credentials, getCredentials } from "./utils/get-credentials";
 import { getPrivateParams, WithPrivate } from "./utils/types";
+import { WithFetchOptions } from "./api-client/api-client";
+import { RUNTIMES } from "./constants";
 
 /** @inline */
 export interface CreateSandboxParams {
@@ -50,10 +52,10 @@ export interface CreateSandboxParams {
   resources?: { vcpus: number };
 
   /**
-   * The runtime of the sandbox, currently only `node22` and `python3.13` are supported.
+   * The runtime of the sandbox, currently only `node24`, `node22` and `python3.13` are supported.
    * If not specified, the default runtime `node22` will be used.
    */
-  runtime?: "node22" | "python3.13" | (string & {});
+  runtime?: RUNTIMES | (string & {});
 
   /**
    * An AbortSignal to cancel sandbox creation.
@@ -135,6 +137,10 @@ export class Sandbox {
     return this.sandbox.id;
   }
 
+  public get interactivePort(): number | undefined {
+    return this.sandbox.interactivePort ?? undefined;
+  }
+
   /**
    * The status of the sandbox.
    */
@@ -160,12 +166,15 @@ export class Sandbox {
    * the next page of results.
    */
   static async list(
-    params: Parameters<APIClient["listSandboxes"]>[0] & Partial<Credentials>,
+    params: Parameters<APIClient["listSandboxes"]>[0] &
+      Partial<Credentials> &
+      WithFetchOptions,
   ) {
     const credentials = await getCredentials(params);
     const client = new APIClient({
       teamId: credentials.teamId,
       token: credentials.token,
+      fetch: params.fetch,
     });
     return client.listSandboxes({
       ...params,
@@ -182,12 +191,14 @@ export class Sandbox {
   static async create(
     params?: WithPrivate<
       CreateSandboxParams | (CreateSandboxParams & Credentials)
-    >,
+    > &
+      WithFetchOptions,
   ): Promise<Sandbox> {
     const credentials = await getCredentials(params);
     const client = new APIClient({
       teamId: credentials.teamId,
       token: credentials.token,
+      fetch: params?.fetch,
     });
 
     const privateParams = getPrivateParams(params);
@@ -216,17 +227,21 @@ export class Sandbox {
    * @returns A promise resolving to the {@link Sandbox}.
    */
   static async get(
-    params: GetSandboxParams | (GetSandboxParams & Credentials),
+    params: WithPrivate<GetSandboxParams | (GetSandboxParams & Credentials)> &
+      WithFetchOptions,
   ): Promise<Sandbox> {
     const credentials = await getCredentials(params);
     const client = new APIClient({
       teamId: credentials.teamId,
       token: credentials.token,
+      fetch: params.fetch,
     });
 
+    const privateParams = getPrivateParams(params);
     const sandbox = await client.getSandbox({
       sandboxId: params.sandboxId,
       signal: params.signal,
+      ...privateParams,
     });
 
     return new Sandbox({
@@ -351,12 +366,19 @@ export class Sandbox {
 
     if (params.stdout || params.stderr) {
       (async () => {
-        for await (const log of command.logs({ signal: params.signal })) {
-          if (log.stream === "stdout") {
-            params.stdout?.write(log.data);
-          } else if (log.stream === "stderr") {
-            params.stderr?.write(log.data);
+        try {
+          for await (const log of command.logs({ signal: params.signal })) {
+            if (log.stream === "stdout") {
+              params.stdout?.write(log.data);
+            } else if (log.stream === "stderr") {
+              params.stderr?.write(log.data);
+            }
+          }
+        } catch (err) {
+          if (params.signal?.aborted) {
+            return;
           }
+          throw err;
         }
       })();
     }
@@ -462,6 +484,11 @@ export class Sandbox {
    * @param opts - Optional parameters.
    * @param opts.signal - An AbortSignal to cancel the operation.
    * @returns A promise that resolves when the timeout is extended
+   *
+   * @example
+   * const sandbox = await Sandbox.create({ timeout: ms('10m') });
+   * // Extends timeout by 5 minutes, to a total of 15 minutes.
+   * await sandbox.extendTimeout(ms('5m'));
    */
   async extendTimeout(
     duration: number,

package/src/version.ts

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

package/tsconfig.json

@@ -6,6 +6,7 @@
     "strict": true,
     "target": "ES2020",
     "declaration": true,
+    "sourceMap": true,
     "module": "commonjs",
     "resolveJsonModule": true
   },