@vercel/sandbox 0.0.4 → 0.0.6

package/dist/create-sandbox.js

@@ -1,230 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Command = exports.Sandbox = exports.SDK = void 0;
-const client_1 = require("./client/client");
-/**
- * SDK for interacting with the Sandbox API. Provides methods to create and
- * manage sandboxes configured with specific source code and network ports.
- *
- * Example:
- * ```ts
- * const sdk = new SDK({
- *   teamId: process.env.VERCEL_TEAM_ID!,
- *   token: process.env.VERCEL_TOKEN!,
- * });
- * ```
- *
- * @see {@link SDK.createSandbox} to start a new sandbox.
- */
-class SDK {
-    /**
-     * Create a new instance of `SDK`.
-     *
-     * @param config - Configuration options for the SDK.
-     * @param config.teamId - The Vercel team ID used to scope the Sandbox.
-     * @param config.token - The API token used for authentication.
-     */
-    constructor({ teamId, token }) {
-        this.client = new client_1.SandboxClient({ teamId, token });
-    }
-    /**
-     * Creates a new sandbox instance using the provided Git repository and exposed ports.
-     *
-     * The repository must be public. On start, the sandbox will clone the repository
-     * and expose the specified ports for access.
-     *
-     * @param params - Configuration parameters for the sandbox.
-     * @param params.source - The source of the sandbox, currently supports Git repositories only.
-     * @param params.source.type - Type of source, must be `"git"`.
-     * @param params.source.url - The URL of the public Git repository to clone.
-     * @param config.projectId - The Vercel project ID used to link the Sandbox to.
-     * @param params.ports - Array of port numbers to expose from the sandbox.
-     * @param params.timeout - (Optional) Timeout in seconds before the sandbox auto-terminates.
-     *
-     * @returns A promise that resolves to a `Sandbox` instance.
-     */
-    async createSandbox(params) {
-        const { client } = this;
-        const sandbox = await client.createSandbox({
-            source: params.source,
-            projectId: params.projectId,
-            ports: params.ports,
-            timeout: params.timeout,
-        });
-        return new Sandbox({
-            client,
-            sandboxId: sandbox.json.sandboxId,
-            routes: sandbox.json.routes,
-        });
-    }
-    /** @hidden */
-    async getSandbox({ routes, sandboxId, }) {
-        return new Sandbox({
-            client: this.client,
-            sandboxId: sandboxId,
-            routes: routes,
-        });
-    }
-}
-exports.SDK = SDK;
-/**
- * A Sandbox is an isolated Linux MicroVM that you can your experiments on.
- *
- * @see {@link SDK.createSandbox} to construct a Sandbox.
- * @hideconstructor
- */
-class Sandbox {
-    constructor({ client, routes, sandboxId, }) {
-        this.client = client;
-        this.routes = routes;
-        this.sandboxId = sandboxId;
-    }
-    /**
-     * Start executing a command in this sandbox.
-     * @param command
-     * @param args
-     * @returns
-     */
-    async runCommand(command, args = []) {
-        const commandResponse = await this.client.runCommand({
-            sandboxId: this.sandboxId,
-            command,
-            args,
-        });
-        return new Command({
-            client: this.client,
-            sandboxId: this.sandboxId,
-            cmdId: commandResponse.json.cmdId,
-        });
-    }
-    /**
-     * Write files to the filesystem of this sandbox.
-     */
-    async writeFiles(files) {
-        return this.client.writeFiles({
-            sandboxId: this.sandboxId,
-            files: files,
-        });
-    }
-    /**
-     * Get the public domain of a port of this sandbox.
-     *
-     * E.g. `2grza2l7imxe.vercel.run`
-     */
-    domain(p) {
-        const route = this.routes.find(({ port }) => port == p);
-        if (route) {
-            return `https://${route.subdomain}.vercel.run`;
-        }
-        else {
-            throw new Error(`No route for port ${p}`);
-        }
-    }
-}
-exports.Sandbox = Sandbox;
-/**
- * A command executed in a Sandbox.
- *
- * You can {@link wait} on commands to access their {@link exitCode}, and
- * iterate over their output with {@link logs}.
- *
- * @see {@link Sandbox.runCommand} to start a command.
- *
- * @hideconstructor
- */
-class Command {
-    constructor({ client, sandboxId, cmdId, }) {
-        this.client = client;
-        this.sandboxId = sandboxId;
-        this.cmdId = cmdId;
-        this.exitCode = null;
-    }
-    /**
-     * Iterate over the output of this command.
-     *
-     * ```
-     * for await (const log of cmd.logs()) {
-     *   if (log.stream === "stdout") {
-     *     process.stdout.write(log.data);
-     *   } else {
-     *     process.stderr.write(log.data);
-     *   }
-     * }
-     * ```
-     *
-     * @see {@link Command.stdout}, {@link Command.stderr}, and {@link Command.output}
-     * to access output as a string.
-     */
-    logs() {
-        return this.client.getLogs({
-            sandboxId: this.sandboxId,
-            cmdId: this.cmdId,
-        });
-    }
-    /**
-     * Wait for a command to exit and populate it's exit code.
-     *
-     * ```
-     * await cmd.wait()
-     * if (cmd.exitCode != 0) {
-     *   console.error("Something went wrong...")
-     * }
-     * ````
-     */
-    async wait() {
-        const command = await this.client.getCommand({
-            sandboxId: this.sandboxId,
-            cmdId: this.cmdId,
-            wait: true,
-        });
-        this.exitCode = command.json.exitCode;
-        return this;
-    }
-    /**
-     * Print command logs to stdout/stderr
-     */
-    async printLogs() {
-        for await (const log of this.logs()) {
-            if (log.stream === "stdout") {
-                process.stdout.write(log.data);
-            }
-            else {
-                process.stderr.write(log.data);
-            }
-        }
-    }
-    /**
-     * Get the output of `stdout` or `stderr` as a string.
-     *
-     * NOTE: This may error with string conversion errors if the command does
-     * not ouptut valid unicode.
-     */
-    async output(stream = "both") {
-        let data = "";
-        for await (const log of this.logs()) {
-            if (log.stream === stream) {
-                data += log.data;
-            }
-        }
-        return data;
-    }
-    /**
-     * Get the output of `stdout` as a string.
-     *
-     * NOTE: This may error with string conversion errors if the command does
-     * not ouptut valid unicode.
-     */
-    async stdout() {
-        return this.output("stdout");
-    }
-    /**
-     * Get the output of `stderr` as a string.
-     *
-     * NOTE: This may error with string conversion errors if the command does
-     * not ouptut valid unicode.
-     */
-    async stderr() {
-        return this.output("stderr");
-    }
-}
-exports.Command = Command;

package/dist/utils/deferred-generator.d.ts

@@ -1,5 +0,0 @@
-export interface DeferredGenerator<T, R> {
-    generator(): AsyncGenerator<T, R, void>;
-    next: (value: IteratorResult<T | Promise<T>>) => void;
-}
-export declare function createDeferredGenerator<T, R>(): DeferredGenerator<T, R>;

package/dist/utils/deferred-generator.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDeferredGenerator = createDeferredGenerator;
-const deferred_1 = require("./deferred");
-function createDeferredGenerator() {
-    const deferreds = [new deferred_1.Deferred()];
-    let currentIndex = 0;
-    const next = (value) => {
-        const currentDeferred = deferreds[currentIndex];
-        if (!value.done) {
-            deferreds.push(new deferred_1.Deferred());
-            currentIndex++;
-        }
-        currentDeferred.resolve(value);
-    };
-    function generator() {
-        let currentIndex = 0;
-        return (async function* () {
-            while (true) {
-                const result = await deferreds[currentIndex].promise;
-                if (result.done)
-                    return result.value;
-                yield result.value;
-                currentIndex++;
-            }
-        })();
-    }
-    return {
-        generator,
-        next,
-    };
-}

package/dist/utils/deferred.d.ts

@@ -1,6 +0,0 @@
-export declare class Deferred<T> {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-    constructor();
-}

package/dist/utils/deferred.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deferred = void 0;
-class Deferred {
-    constructor() {
-        this.promise = new Promise((res, rej) => {
-            this.resolve = res;
-            this.reject = rej;
-        });
-    }
-}
-exports.Deferred = Deferred;

package/src/client/client.ts

@@ -1,186 +0,0 @@
-import FormData from "form-data";
-import { APIClient, parseOrThrow, type RequestParams } from "./base-client";
-import {
-  Command,
-  CreatedCommand,
-  CreatedSandbox,
-  LogLine,
-  WrittenFile,
-} from "./validators";
-import { Readable } from "stream";
-import { APIError } from "./api-error";
-import { createDeferredGenerator } from "../utils/deferred-generator";
-import { VERSION } from "../version";
-import { z } from "zod";
-import jsonlines from "jsonlines";
-import os from "os";
-
-export class SandboxClient extends APIClient {
-  private teamId: string;
-
-  constructor(params: { host?: string; teamId: string; token: string }) {
-    super({
-      host: params.host ?? "https://api.vercel.com",
-      token: params.token,
-      debug: false,
-    });
-
-    this.teamId = params.teamId;
-  }
-
-  protected async request(path: string, params?: RequestParams) {
-    return super.request(path, {
-      ...params,
-      query: { teamId: this.teamId, ...params?.query },
-      headers: {
-        "content-type": "application/json",
-        "user-agent": `vercel/sandbox/${VERSION} (Node.js/${process.version}; ${os.platform()}/${os.arch()})`,
-        ...params?.headers,
-      },
-    });
-  }
-
-  async createSandbox(params: {
-    ports: number[];
-    projectId: string;
-    source: { type: "git"; url: string };
-    timeout?: number;
-  }) {
-    return parseOrThrow(
-      CreatedSandbox,
-      await this.request("/v1/sandboxes", {
-        method: "POST",
-        body: JSON.stringify({
-          projectId: params.projectId,
-          ports: params.ports,
-          source: params.source,
-          timeout: params.timeout,
-        }),
-      }),
-    );
-  }
-
-  async runCommand(params: {
-    sandboxId: string;
-    cwd?: string;
-    command: string;
-    args: string[];
-  }) {
-    return parseOrThrow(
-      CreatedCommand,
-      await this.request(`/v1/sandboxes/${params.sandboxId}/cmd`, {
-        method: "POST",
-        body: JSON.stringify({
-          command: params.command,
-          args: params.args,
-          cwd: params.cwd,
-        }),
-      }),
-    );
-  }
-
-  async getCommand(params: {
-    sandboxId: string;
-    cmdId: string;
-    wait?: boolean;
-  }) {
-    return parseOrThrow(
-      Command,
-      await this.request(
-        `/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`,
-        { query: { wait: params.wait ? "true" : undefined } },
-      ),
-    );
-  }
-
-  async writeFiles(params: {
-    sandboxId: string;
-    files: { path: string; stream: Readable | Buffer }[];
-  }) {
-    const formData = new FormData();
-
-    for (const file of params.files) {
-      formData.append(file.path, file.stream, file.path);
-    }
-
-    await parseOrThrow(
-      WrittenFile,
-      await this.request(`/v1/sandboxes/${params.sandboxId}/fs/write`, {
-        method: "POST",
-        headers: { ...formData.getHeaders() },
-        body: formData,
-      }),
-    );
-  }
-
-  async readFile(params: {
-    sandboxId: string;
-    path: string;
-    cwd?: string;
-  }): 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 }),
-      },
-    );
-
-    if (response.status === 404) {
-      return null;
-    }
-
-    return response.body;
-  }
-
-  getLogs(params: { sandboxId: string; cmdId: string }) {
-    const deferred = createDeferredGenerator<z.infer<typeof LogLine>, void>();
-
-    (async () => {
-      const response = await this.request(
-        `/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}/logs`,
-        { method: "GET" },
-      );
-
-      if (response.headers.get("content-type") !== "application/x-ndjson") {
-        throw new APIError(response, {
-          message: "Expected a stream of logs",
-        });
-      }
-
-      const parser = jsonlines.parse();
-      response.body.pipe(parser);
-
-      parser.on("data", (data) => {
-        const parsed = LogLine.safeParse(data);
-        if (parsed.success) {
-          deferred.next({
-            value: parsed.data,
-            done: false,
-          });
-        } else {
-          deferred.next({
-            value: Promise.reject(parsed.error),
-            done: false,
-          });
-        }
-      });
-
-      parser.on("error", (err) => {
-        deferred.next({
-          value: Promise.reject(err),
-          done: false,
-        });
-      });
-
-      parser.on("end", () => {
-        deferred.next({
-          value: undefined,
-          done: true,
-        });
-      });
-    })();
-
-    return deferred.generator();
-  }
-}