@vercel/sandbox 0.0.15 → 0.0.17

package/.turbo/turbo-build.log

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

package/.turbo/turbo-typecheck.log

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

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @vercel/sandbox
 
+## 0.0.17
+
+### Patch Changes
+
+- Sandboxes can now expose up to 4 ports ([#99](https://github.com/vercel/sandbox-sdk/pull/99))
+
+  This applies to all SDK versions, but this SDK release documents the limit.
+
+- Fix bug in Sandbox.writeFile, add support for absolute paths ([#97](https://github.com/vercel/sandbox-sdk/pull/97))
+
+## 0.0.16
+
+### Patch Changes
+
+- Add sandbox.status property ([#95](https://github.com/vercel/sandbox-sdk/pull/95))
+
 ## 0.0.15
 
 ### Patch Changes

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

@@ -9,20 +9,21 @@ export declare class APIClient extends BaseClient {
         teamId: string;
         token: string;
     });
-    protected request(path: string, params?: RequestParams): Promise<import("node-fetch").Response>;
+    protected request(path: string, params?: RequestParams): Promise<Response>;
     getSandbox(params: {
         sandboxId: string;
     }): Promise<Parsed<{
         sandbox: {
             region: string;
-            timeout: number;
             status: "pending" | "running" | "stopping" | "stopped" | "failed";
             id: string;
             memory: number;
             vcpus: number;
             runtime: string;
+            timeout: number;
             requestedAt: number;
             createdAt: number;
+            cwd: string;
             updatedAt: number;
             duration?: number | undefined;
             startedAt?: number | undefined;
@@ -30,9 +31,9 @@ export declare class APIClient extends BaseClient {
             stoppedAt?: number | undefined;
         };
         routes: {
-            port: number;
             url: string;
             subdomain: string;
+            port: number;
         }[];
     }>>;
     createSandbox(params: {
@@ -57,14 +58,15 @@ export declare class APIClient extends BaseClient {
     }): Promise<Parsed<{
         sandbox: {
             region: string;
-            timeout: number;
             status: "pending" | "running" | "stopping" | "stopped" | "failed";
             id: string;
             memory: number;
             vcpus: number;
             runtime: string;
+            timeout: number;
             requestedAt: number;
             createdAt: number;
+            cwd: string;
             updatedAt: number;
             duration?: number | undefined;
             startedAt?: number | undefined;
@@ -72,9 +74,9 @@ export declare class APIClient extends BaseClient {
             stoppedAt?: number | undefined;
         };
         routes: {
-            port: number;
             url: string;
             subdomain: string;
+            port: number;
         }[];
     }>>;
     runCommand(params: {
@@ -87,10 +89,10 @@ export declare class APIClient extends BaseClient {
     }): Promise<Parsed<{
         command: {
             name: string;
-            cwd: string;
             args: string[];
             id: string;
             startedAt: number;
+            cwd: string;
             sandboxId: string;
             exitCode: number | null;
         };
@@ -112,16 +114,19 @@ export declare class APIClient extends BaseClient {
     }): Promise<Parsed<{}>>;
     getFileWriter(params: {
         sandboxId: string;
+        extractDir: string;
     }): {
-        response: Promise<import("node-fetch").Response>;
+        response: Promise<Response>;
         writer: FileWriter;
     };
     writeFiles(params: {
         sandboxId: string;
+        cwd: string;
         files: {
             path: string;
             content: Buffer;
         }[];
+        extractDir: string;
     }): Promise<void>;
     readFile(params: {
         sandboxId: string;
@@ -135,10 +140,10 @@ export declare class APIClient extends BaseClient {
     }): Promise<Parsed<{
         command: {
             name: string;
-            cwd: string;
             args: string[];
             id: string;
             startedAt: number;
+            cwd: string;
             sandboxId: string;
             exitCode: number | null;
         };

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

@@ -12,6 +12,8 @@ const version_1 = require("../version");
 const consume_readable_1 = require("../utils/consume-readable");
 const jsonlines_1 = __importDefault(require("jsonlines"));
 const os_1 = __importDefault(require("os"));
+const stream_1 = require("stream");
+const normalizePath_1 = require("../utils/normalizePath");
 class APIClient extends base_client_1.BaseClient {
     constructor(params) {
         super({
@@ -77,7 +79,10 @@ class APIClient extends base_client_1.BaseClient {
             response: (async () => {
                 return this.request(`/v1/sandboxes/${params.sandboxId}/fs/write`, {
                     method: "POST",
-                    headers: { "content-type": "application/gzip" },
+                    headers: {
+                        "content-type": "application/gzip",
+                        "x-cwd": params.extractDir,
+                    },
                     body: await (0, consume_readable_1.consumeReadable)(writer.readable),
                 });
             })(),
@@ -87,9 +92,17 @@ class APIClient extends base_client_1.BaseClient {
     async writeFiles(params) {
         const { writer, response } = this.getFileWriter({
             sandboxId: params.sandboxId,
+            extractDir: params.extractDir,
         });
         for (const file of params.files) {
-            await writer.addFile({ name: file.path, content: file.content });
+            await writer.addFile({
+                name: (0, normalizePath_1.normalizePath)({
+                    filePath: file.path,
+                    extractDir: params.extractDir,
+                    cwd: params.cwd,
+                }),
+                content: file.content,
+            });
         }
         writer.end();
         await (0, base_client_1.parseOrThrow)(validators_1.EmptyResponse, await response);
@@ -102,7 +115,10 @@ class APIClient extends base_client_1.BaseClient {
         if (response.status === 404) {
             return null;
         }
-        return response.body;
+        if (response.body === null) {
+            return null;
+        }
+        return stream_1.Readable.fromWeb(response.body);
     }
     async killCommand(params) {
         return (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/${params.commandId}/kill`, {
@@ -118,7 +134,12 @@ class APIClient extends base_client_1.BaseClient {
                 message: "Expected a stream of logs",
             });
         }
-        for await (const chunk of response.body.pipe(jsonlines_1.default.parse())) {
+        if (response.body === null) {
+            throw new api_error_1.APIError(response, {
+                message: "No response body",
+            });
+        }
+        for await (const chunk of stream_1.Readable.fromWeb(response.body).pipe(jsonlines_1.default.parse())) {
             yield validators_1.LogLine.parse(chunk);
         }
     }

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

@@ -1,4 +1,3 @@
-import type { Response } from "node-fetch";
 interface Options<ErrorData> {
     message?: string;
     json?: ErrorData;

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

@@ -2,7 +2,6 @@ import type { Options as RetryOptions } from "async-retry";
 import { APIError } from "./api-error";
 import { ZodType } from "zod";
 import { type RequestOptions } from "./with-retry";
-import nodeFetch, { type Response, type RequestInit } from "node-fetch";
 export interface RequestParams extends RequestInit {
     headers?: Record<string, string>;
     method?: string;
@@ -25,7 +24,7 @@ export declare class BaseClient {
         host: string;
         token?: string;
     });
-    protected request(path: string, opts?: RequestParams): Promise<nodeFetch.Response>;
+    protected request(path: string, opts?: RequestParams): Promise<Response>;
 }
 export interface Parsed<Data> {
     response: Response;

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

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseClient = void 0;
 exports.parse = parse;
@@ -9,7 +6,6 @@ exports.parseOrThrow = parseOrThrow;
 const api_error_1 = require("./api-error");
 const array_1 = require("../utils/array");
 const with_retry_1 = require("./with-retry");
-const node_fetch_1 = __importDefault(require("node-fetch"));
 /**
  * A base API client that provides a convenience wrapper for fetching where
  * we can pass query parameters as an object, support retries, debugging
@@ -17,7 +13,7 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
  */
 class BaseClient {
     constructor(params) {
-        this.fetch = (0, with_retry_1.withRetry)(node_fetch_1.default);
+        this.fetch = (0, with_retry_1.withRetry)(globalThis.fetch);
         this.host = params.host;
         this.debug = params.debug ?? process.env.DEBUG_FETCH === "true";
         this.token = params.token;

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export type SandboxData = z.infer<typeof Sandbox>;
+export type SandboxMetaData = z.infer<typeof Sandbox>;
 export declare const Sandbox: z.ZodObject<{
     id: z.ZodString;
     memory: z.ZodNumber;
@@ -14,17 +14,19 @@ export declare const Sandbox: z.ZodObject<{
     stoppedAt: z.ZodOptional<z.ZodNumber>;
     duration: z.ZodOptional<z.ZodNumber>;
     createdAt: z.ZodNumber;
+    cwd: z.ZodString;
     updatedAt: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     region: string;
-    timeout: number;
     status: "pending" | "running" | "stopping" | "stopped" | "failed";
     id: string;
     memory: number;
     vcpus: number;
     runtime: string;
+    timeout: number;
     requestedAt: number;
     createdAt: number;
+    cwd: string;
     updatedAt: number;
     duration?: number | undefined;
     startedAt?: number | undefined;
@@ -32,14 +34,15 @@ export declare const Sandbox: z.ZodObject<{
     stoppedAt?: number | undefined;
 }, {
     region: string;
-    timeout: number;
     status: "pending" | "running" | "stopping" | "stopped" | "failed";
     id: string;
     memory: number;
     vcpus: number;
     runtime: string;
+    timeout: number;
     requestedAt: number;
     createdAt: number;
+    cwd: string;
     updatedAt: number;
     duration?: number | undefined;
     startedAt?: number | undefined;
@@ -52,13 +55,13 @@ export declare const SandboxRoute: z.ZodObject<{
     subdomain: z.ZodString;
     port: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    port: number;
     url: string;
     subdomain: string;
-}, {
     port: number;
+}, {
     url: string;
     subdomain: string;
+    port: number;
 }>;
 export type CommandData = z.infer<typeof Command>;
 export declare const Command: z.ZodObject<{
@@ -71,18 +74,18 @@ export declare const Command: z.ZodObject<{
     startedAt: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    cwd: string;
     args: string[];
     id: string;
     startedAt: number;
+    cwd: string;
     sandboxId: string;
     exitCode: number | null;
 }, {
     name: string;
-    cwd: string;
     args: string[];
     id: string;
     startedAt: number;
+    cwd: string;
     sandboxId: string;
     exitCode: number | null;
 }>;
@@ -101,17 +104,19 @@ export declare const SandboxResponse: z.ZodObject<{
         stoppedAt: z.ZodOptional<z.ZodNumber>;
         duration: z.ZodOptional<z.ZodNumber>;
         createdAt: z.ZodNumber;
+        cwd: z.ZodString;
         updatedAt: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -119,14 +124,15 @@ export declare const SandboxResponse: z.ZodObject<{
         stoppedAt?: number | undefined;
     }, {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -136,14 +142,15 @@ export declare const SandboxResponse: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     sandbox: {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -153,14 +160,15 @@ export declare const SandboxResponse: z.ZodObject<{
 }, {
     sandbox: {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -183,17 +191,19 @@ export declare const SandboxAndRoutesResponse: z.ZodObject<{
         stoppedAt: z.ZodOptional<z.ZodNumber>;
         duration: z.ZodOptional<z.ZodNumber>;
         createdAt: z.ZodNumber;
+        cwd: z.ZodString;
         updatedAt: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -201,14 +211,15 @@ export declare const SandboxAndRoutesResponse: z.ZodObject<{
         stoppedAt?: number | undefined;
     }, {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -221,25 +232,26 @@ export declare const SandboxAndRoutesResponse: z.ZodObject<{
         subdomain: z.ZodString;
         port: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        port: number;
         url: string;
         subdomain: string;
-    }, {
         port: number;
+    }, {
         url: string;
         subdomain: string;
+        port: number;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     sandbox: {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -247,21 +259,22 @@ export declare const SandboxAndRoutesResponse: z.ZodObject<{
         stoppedAt?: number | undefined;
     };
     routes: {
-        port: number;
         url: string;
         subdomain: string;
+        port: number;
     }[];
 }, {
     sandbox: {
         region: string;
-        timeout: number;
         status: "pending" | "running" | "stopping" | "stopped" | "failed";
         id: string;
         memory: number;
         vcpus: number;
         runtime: string;
+        timeout: number;
         requestedAt: number;
         createdAt: number;
+        cwd: string;
         updatedAt: number;
         duration?: number | undefined;
         startedAt?: number | undefined;
@@ -269,9 +282,9 @@ export declare const SandboxAndRoutesResponse: z.ZodObject<{
         stoppedAt?: number | undefined;
     };
     routes: {
-        port: number;
         url: string;
         subdomain: string;
+        port: number;
     }[];
 }>;
 export declare const CommandResponse: z.ZodObject<{
@@ -285,38 +298,38 @@ export declare const CommandResponse: z.ZodObject<{
         startedAt: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number | null;
     }, {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number | null;
     }>;
 }, "strip", z.ZodTypeAny, {
     command: {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number | null;
     };
 }, {
     command: {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number | null;
     };
@@ -333,38 +346,38 @@ export declare const CommandFinishedResponse: z.ZodObject<{
         exitCode: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number;
     }, {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number;
     }>;
 }, "strip", z.ZodTypeAny, {
     command: {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number;
     };
 }, {
     command: {
         name: string;
-        cwd: string;
         args: string[];
         id: string;
         startedAt: number;
+        cwd: string;
         sandboxId: string;
         exitCode: number;
     };
@@ -374,9 +387,9 @@ export declare const LogLine: z.ZodObject<{
     stream: z.ZodEnum<["stdout", "stderr"]>;
     data: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    data: string;
     stream: "stdout" | "stderr";
-}, {
     data: string;
+}, {
     stream: "stdout" | "stderr";
+    data: string;
 }>;

package/dist/api-client/validators.js

@@ -16,6 +16,7 @@ exports.Sandbox = zod_1.z.object({
     stoppedAt: zod_1.z.number().optional(),
     duration: zod_1.z.number().optional(),
     createdAt: zod_1.z.number(),
+    cwd: zod_1.z.string(),
     updatedAt: zod_1.z.number(),
 });
 exports.SandboxRoute = zod_1.z.object({

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

@@ -1,4 +1,3 @@
-import type { RequestInit, Response } from "node-fetch";
 import type { Options as RetryOptions } from "async-retry";
 export interface RequestOptions {
     onRetry?(error: any, options: RequestOptions): void;

package/dist/command.d.ts

@@ -3,8 +3,11 @@ import { Signal } from "./utils/resolveSignal";
 /**
  * A command executed in a Sandbox.
  *
- * You can {@link wait} on commands to access their {@link CommandFinished.exitCode}, and
- * iterate over their output with {@link logs}.
+ * For detached commands, you can {@link wait} to get a {@link CommandFinished} instance
+ * with the populated exit code. For non-detached commands, {@link Sandbox.runCommand}
+ * automatically waits and returns a {@link CommandFinished} instance.
+ *
+ * You can iterate over command output with {@link logs}.
  *
  * @see {@link Sandbox.runCommand} to start a command.
  *
@@ -61,15 +64,20 @@ export declare class Command {
      * to access output as a string.
      */
     logs(): AsyncIterable<{
-        data: string;
         stream: "stdout" | "stderr";
+        data: string;
     }>;
     /**
      * Wait for a command to exit and populate its exit code.
      *
+     * This method is useful for detached commands where you need to wait
+     * for completion. For non-detached commands, {@link Sandbox.runCommand}
+     * automatically waits and returns a {@link CommandFinished} instance.
+     *
      * ```
-     * await cmd.wait()
-     * if (cmd.exitCode != 0) {
+     * const detachedCmd = await sandbox.runCommand({ cmd: 'sleep', args: ['5'], detached: true });
+     * const result = await detachedCmd.wait();
+     * if (result.exitCode !== 0) {
      *   console.error("Something went wrong...")
      * }
      * ```
@@ -117,14 +125,16 @@ export declare class Command {
 /**
  * A command that has finished executing.
  *
- * Contains the exit code of the command.
+ * The exit code is immediately available and populated upon creation.
+ * Unlike {@link Command}, you don't need to call wait() - the command
+ * has already completed execution.
  *
  * @hideconstructor
  */
 export declare class CommandFinished extends Command {
     /**
-     * The exit code of the command, if available. This is set after
-     * {@link wait} has returned.
+     * The exit code of the command. This is always populated for
+     * CommandFinished instances.
      */
     exitCode: number;
     /**
@@ -140,4 +150,13 @@ export declare class CommandFinished extends Command {
         cmd: CommandData;
         exitCode: number;
     });
+    /**
+     * The wait method is not needed for CommandFinished instances since
+     * the command has already completed and exitCode is populated.
+     *
+     * @deprecated This method is redundant for CommandFinished instances.
+     * The exitCode is already available.
+     * @returns This CommandFinished instance.
+     */
+    wait(): Promise<CommandFinished>;
 }