@vercel/sandbox 0.0.8 → 0.0.9

package/.turbo/turbo-build.log

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

package/.turbo/turbo-typecheck.log

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

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @vercel/sandbox
 
+## 0.0.9
+
+### Patch Changes
+
+- Add `cmd.kill()` to stop/signal commands ([#48](https://github.com/vercel/sandbox-sdk/pull/48))
+- Update SDK to use the new API ([#51](https://github.com/vercel/sandbox-sdk/pull/51))
+
 ## 0.0.8
 
 ### Patch Changes

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

@@ -1,5 +1,5 @@
 import { BaseClient, type Parsed, type RequestParams } from "./base-client";
-import { Command, CommandFinished, LogLine, StoppedSandbox } from "./validators";
+import { SandboxResponse, CommandResponse, CommandFinishedResponse, LogLine } from "./validators";
 import { FileWriter } from "./file-writer";
 import { z } from "zod";
 export declare class APIClient extends BaseClient {
@@ -10,6 +10,31 @@ export declare class APIClient extends BaseClient {
         token: string;
     });
     protected request(path: string, params?: RequestParams): Promise<import("node-fetch").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;
+            requestedAt: number;
+            createdAt: number;
+            updatedAt: number;
+            duration?: number | undefined;
+            startedAt?: number | undefined;
+            requestedStopAt?: number | undefined;
+            stoppedAt?: number | undefined;
+        };
+        routes: {
+            port: number;
+            url: string;
+            subdomain: string;
+        }[];
+    }>>;
     createSandbox(params: {
         ports?: number[];
         projectId: string;
@@ -28,9 +53,25 @@ export declare class APIClient extends BaseClient {
         };
         runtime?: "node22" | "python3.13";
     }): Promise<Parsed<{
-        sandboxId: string;
+        sandbox: {
+            region: string;
+            timeout: number;
+            status: "pending" | "running" | "stopping" | "stopped" | "failed";
+            id: string;
+            memory: number;
+            vcpus: number;
+            runtime: string;
+            requestedAt: number;
+            createdAt: number;
+            updatedAt: number;
+            duration?: number | undefined;
+            startedAt?: number | undefined;
+            requestedStopAt?: number | undefined;
+            stoppedAt?: number | undefined;
+        };
         routes: {
             port: number;
+            url: string;
             subdomain: string;
         }[];
     }>>;
@@ -41,18 +82,26 @@ export declare class APIClient extends BaseClient {
         args: string[];
         env: Record<string, string>;
     }): Promise<Parsed<{
-        cmdId: string;
+        command: {
+            name: string;
+            cwd: string;
+            args: string[];
+            id: string;
+            startedAt: number;
+            sandboxId: string;
+            exitCode: number | null;
+        };
     }>>;
     getCommand(params: {
         sandboxId: string;
         cmdId: string;
         wait: true;
-    }): Promise<Parsed<z.infer<typeof CommandFinished>>>;
+    }): Promise<Parsed<z.infer<typeof CommandFinishedResponse>>>;
     getCommand(params: {
         sandboxId: string;
         cmdId: string;
         wait?: boolean;
-    }): Promise<Parsed<z.infer<typeof Command>>>;
+    }): Promise<Parsed<z.infer<typeof CommandResponse>>>;
     mkDir(params: {
         sandboxId: string;
         path: string;
@@ -76,11 +125,26 @@ export declare class APIClient extends BaseClient {
         path: string;
         cwd?: string;
     }): Promise<NodeJS.ReadableStream | null>;
+    killCommand(params: {
+        sandboxId: string;
+        commandId: string;
+        signal: number;
+    }): Promise<Parsed<{
+        command: {
+            name: string;
+            cwd: string;
+            args: string[];
+            id: string;
+            startedAt: number;
+            sandboxId: string;
+            exitCode: number | null;
+        };
+    }>>;
     getLogs(params: {
         sandboxId: string;
         cmdId: string;
     }): AsyncIterable<z.infer<typeof LogLine>>;
     stopSandbox(params: {
         sandboxId: string;
-    }): Promise<Parsed<z.infer<typeof StoppedSandbox>>>;
+    }): Promise<Parsed<z.infer<typeof SandboxResponse>>>;
 }

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

@@ -41,8 +41,11 @@ 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}`));
+    }
     async createSandbox(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.CreatedSandbox, await this.request("/v1/sandboxes", {
+        return (0, base_client_1.parseOrThrow)(validators_1.SandboxAndRoutesResponse, await this.request("/v1/sandboxes", {
             method: "POST",
             body: JSON.stringify({
                 projectId: params.projectId,
@@ -55,7 +58,7 @@ class APIClient extends base_client_1.BaseClient {
         }));
     }
     async runCommand(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.CreatedCommand, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd`, {
+        return (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd`, {
             method: "POST",
             body: JSON.stringify({
                 command: params.command,
@@ -67,11 +70,11 @@ class APIClient extends base_client_1.BaseClient {
     }
     async getCommand(params) {
         return params.wait
-            ? (0, base_client_1.parseOrThrow)(validators_1.CommandFinished, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { query: { wait: "true" } }))
-            : (0, base_client_1.parseOrThrow)(validators_1.Command, 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}`, { query: { wait: "true" } }))
+            : (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`));
     }
     async mkDir(params) {
-        return (0, base_client_1.parseOrThrow)(validators_1.WrittenFile, await this.request(`/v1/sandboxes/${params.sandboxId}/fs/mkdir`, {
+        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 }),
         }));
@@ -95,7 +98,7 @@ class APIClient extends base_client_1.BaseClient {
             await writer.addFile({ name: file.path, content: file.stream });
         }
         await writer.end();
-        await (0, base_client_1.parseOrThrow)(validators_1.WrittenFile, await response);
+        await (0, base_client_1.parseOrThrow)(validators_1.EmptyResponse, await response);
     }
     async readFile(params) {
         const response = await this.request(`/v1/sandboxes/${params.sandboxId}/fs/read`, {
@@ -107,6 +110,12 @@ class APIClient extends base_client_1.BaseClient {
         }
         return response.body;
     }
+    async killCommand(params) {
+        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 }),
+        }));
+    }
     async *getLogs(params) {
         const url = `/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}/logs`;
         const response = await this.request(url, { method: "GET" });
@@ -133,7 +142,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.StoppedSandbox, await this.request(url, { method: "POST" }));
+        return (0, base_client_1.parseOrThrow)(validators_1.SandboxResponse, await this.request(url, { method: "POST" }));
     }
 }
 exports.APIClient = APIClient;

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

@@ -1 +1,2 @@
 export { APIClient } from "./api-client";
+export * from "./validators";

package/dist/api-client/index.js

@@ -1,5 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APIClient = void 0;
 var api_client_1 = require("./api-client");
 Object.defineProperty(exports, "APIClient", { enumerable: true, get: function () { return api_client_1.APIClient; } });
+__exportStar(require("./validators"), exports);

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

@@ -1,82 +1,375 @@
 import { z } from "zod";
-export declare const CreatedSandbox: z.ZodObject<{
+export type SandboxData = z.infer<typeof Sandbox>;
+export declare const Sandbox: z.ZodObject<{
+    id: z.ZodString;
+    memory: z.ZodNumber;
+    vcpus: z.ZodNumber;
+    region: z.ZodString;
+    runtime: z.ZodString;
+    timeout: z.ZodNumber;
+    status: z.ZodEnum<["pending", "running", "stopping", "stopped", "failed"]>;
+    requestedAt: z.ZodNumber;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    requestedStopAt: z.ZodOptional<z.ZodNumber>;
+    stoppedAt: z.ZodOptional<z.ZodNumber>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    region: string;
+    timeout: number;
+    status: "pending" | "running" | "stopping" | "stopped" | "failed";
+    id: string;
+    memory: number;
+    vcpus: number;
+    runtime: string;
+    requestedAt: number;
+    createdAt: number;
+    updatedAt: number;
+    duration?: number | undefined;
+    startedAt?: number | undefined;
+    requestedStopAt?: number | undefined;
+    stoppedAt?: number | undefined;
+}, {
+    region: string;
+    timeout: number;
+    status: "pending" | "running" | "stopping" | "stopped" | "failed";
+    id: string;
+    memory: number;
+    vcpus: number;
+    runtime: string;
+    requestedAt: number;
+    createdAt: number;
+    updatedAt: number;
+    duration?: number | undefined;
+    startedAt?: number | undefined;
+    requestedStopAt?: number | undefined;
+    stoppedAt?: number | undefined;
+}>;
+export type SandboxRouteData = z.infer<typeof SandboxRoute>;
+export declare const SandboxRoute: z.ZodObject<{
+    url: z.ZodString;
+    subdomain: z.ZodString;
+    port: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    url: string;
+    subdomain: string;
+}, {
+    port: number;
+    url: string;
+    subdomain: string;
+}>;
+export type CommandData = z.infer<typeof Command>;
+export declare const Command: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    args: z.ZodArray<z.ZodString, "many">;
+    cwd: z.ZodString;
     sandboxId: z.ZodString;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    startedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    cwd: string;
+    args: string[];
+    id: string;
+    startedAt: number;
+    sandboxId: string;
+    exitCode: number | null;
+}, {
+    name: string;
+    cwd: string;
+    args: string[];
+    id: string;
+    startedAt: number;
+    sandboxId: string;
+    exitCode: number | null;
+}>;
+export declare const SandboxResponse: z.ZodObject<{
+    sandbox: z.ZodObject<{
+        id: z.ZodString;
+        memory: z.ZodNumber;
+        vcpus: z.ZodNumber;
+        region: z.ZodString;
+        runtime: z.ZodString;
+        timeout: z.ZodNumber;
+        status: z.ZodEnum<["pending", "running", "stopping", "stopped", "failed"]>;
+        requestedAt: z.ZodNumber;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        requestedStopAt: z.ZodOptional<z.ZodNumber>;
+        stoppedAt: z.ZodOptional<z.ZodNumber>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    }, {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    sandbox: {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    };
+}, {
+    sandbox: {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    };
+}>;
+export declare const SandboxAndRoutesResponse: z.ZodObject<{
+    sandbox: z.ZodObject<{
+        id: z.ZodString;
+        memory: z.ZodNumber;
+        vcpus: z.ZodNumber;
+        region: z.ZodString;
+        runtime: z.ZodString;
+        timeout: z.ZodNumber;
+        status: z.ZodEnum<["pending", "running", "stopping", "stopped", "failed"]>;
+        requestedAt: z.ZodNumber;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        requestedStopAt: z.ZodOptional<z.ZodNumber>;
+        stoppedAt: z.ZodOptional<z.ZodNumber>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    }, {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    }>;
+} & {
     routes: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
         subdomain: z.ZodString;
         port: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         port: number;
+        url: string;
         subdomain: string;
     }, {
         port: number;
+        url: string;
         subdomain: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    sandboxId: string;
+    sandbox: {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    };
     routes: {
         port: number;
+        url: string;
         subdomain: string;
     }[];
 }, {
-    sandboxId: string;
+    sandbox: {
+        region: string;
+        timeout: number;
+        status: "pending" | "running" | "stopping" | "stopped" | "failed";
+        id: string;
+        memory: number;
+        vcpus: number;
+        runtime: string;
+        requestedAt: number;
+        createdAt: number;
+        updatedAt: number;
+        duration?: number | undefined;
+        startedAt?: number | undefined;
+        requestedStopAt?: number | undefined;
+        stoppedAt?: number | undefined;
+    };
     routes: {
         port: number;
+        url: string;
         subdomain: string;
     }[];
 }>;
-export declare const CreatedCommand: z.ZodObject<{
-    cmdId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    cmdId: string;
-}, {
-    cmdId: string;
-}>;
-export declare const Command: z.ZodObject<{
-    args: z.ZodArray<z.ZodString, "many">;
-    cmdId: z.ZodString;
-    cwd: z.ZodString;
-    exitCode: z.ZodNullable<z.ZodNumber>;
-    name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    cwd: string;
-    args: string[];
-    cmdId: string;
-    exitCode: number | null;
-}, {
-    name: string;
-    cwd: string;
-    args: string[];
-    cmdId: string;
-    exitCode: number | null;
-}>;
-export declare const CommandFinished: z.ZodObject<{
-    args: z.ZodArray<z.ZodString, "many">;
-    cmdId: z.ZodString;
-    cwd: z.ZodString;
-    exitCode: z.ZodNumber;
-    name: z.ZodString;
+export declare const CommandResponse: z.ZodObject<{
+    command: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        args: z.ZodArray<z.ZodString, "many">;
+        cwd: z.ZodString;
+        sandboxId: z.ZodString;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        startedAt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number | null;
+    }, {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number | null;
+    }>;
 }, "strip", z.ZodTypeAny, {
-    name: string;
-    cwd: string;
-    args: string[];
-    cmdId: string;
-    exitCode: number;
+    command: {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number | null;
+    };
 }, {
-    name: string;
-    cwd: string;
-    args: string[];
-    cmdId: string;
-    exitCode: number;
+    command: {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number | null;
+    };
 }>;
-export declare const WrittenFile: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const StoppedSandbox: z.ZodObject<{
-    sandboxId: z.ZodString;
+export declare const CommandFinishedResponse: z.ZodObject<{
+    command: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        args: z.ZodArray<z.ZodString, "many">;
+        cwd: z.ZodString;
+        sandboxId: z.ZodString;
+        startedAt: z.ZodNumber;
+    } & {
+        exitCode: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number;
+    }, {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number;
+    }>;
 }, "strip", z.ZodTypeAny, {
-    sandboxId: string;
+    command: {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number;
+    };
 }, {
-    sandboxId: string;
+    command: {
+        name: string;
+        cwd: string;
+        args: string[];
+        id: string;
+        startedAt: number;
+        sandboxId: string;
+        exitCode: number;
+    };
 }>;
+export declare const EmptyResponse: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export declare const LogLine: z.ZodObject<{
     stream: z.ZodEnum<["stdout", "stderr"]>;
     data: z.ZodString;