@vercel/sandbox 0.0.5 → 0.0.6

package/src/create-sandbox.ts

@@ -1,330 +0,0 @@
-import { SandboxClient } from "./client/client";
-import { Readable } from "stream";
-
-/**
- * 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.
- */
-export class SDK {
-  /**
-   * Internal API client for communicating with the sandbox backend.
-   */
-  private client: SandboxClient;
-
-  /**
-   * 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 }: { teamId: string; token: string }) {
-    this.client = new 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 params.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: {
-    source: { type: "git"; url: string };
-    projectId: string;
-    ports?: number[];
-    timeout?: number;
-  }) {
-    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,
-  }: {
-    routes: { subdomain: string; port: number }[];
-    sandboxId: string;
-  }) {
-    return new Sandbox({
-      client: this.client,
-      sandboxId: sandboxId,
-      routes: routes,
-    });
-  }
-}
-
-/** @inline */
-interface RunCommandParams {
-  /** The command to execute */
-  cmd: string;
-  /** Arguments to pass to the command */
-  args?: string[];
-  /** Working directory to execute the command in */
-  cwd?: string;
-  /** Environment variables to set for this command */
-  env?: Record<string, string>;
-}
-
-/**
- * A Sandbox is an isolated Linux MicroVM that you can your experiments on.
- *
- * @see {@link SDK.createSandbox} to construct a Sandbox.
- * @hideconstructor
- */
-export class Sandbox {
-  private client: SandboxClient;
-
-  /** @hidden */
-  public routes: { subdomain: string; port: number }[];
-
-  /**
-   * The ID of this sandbox.
-   */
-  public sandboxId: string;
-
-  constructor({
-    client,
-    routes,
-    sandboxId,
-  }: {
-    client: SandboxClient;
-    routes: { subdomain: string; port: number }[];
-    sandboxId: string;
-  }) {
-    this.client = client;
-    this.routes = routes;
-    this.sandboxId = sandboxId;
-  }
-
-  /**
-   * Start executing a command in this sandbox.
-   *
-   * @param command - The command to execute.
-   * @param args - Arguments to pass to the command.
-   *
-   * @returns A {@link Command} instance.
-   */
-  async runCommand(command: string, args?: string[]): Promise<Command>;
-
-  /**
-   * Start executing a command in this sandbox.
-   *
-   * @param params - What should be executed.
-   *
-   * @returns A {@link Command} instance.
-   */
-  async runCommand(params: RunCommandParams): Promise<Command>;
-
-  async runCommand(
-    commandOrParams: string | RunCommandParams,
-    args?: string[],
-  ): Promise<Command> {
-    return typeof commandOrParams === "string"
-      ? this._runCommand({ cmd: commandOrParams, args })
-      : this._runCommand(commandOrParams);
-  }
-
-  async _runCommand(params: RunCommandParams) {
-    const commandResponse = await this.client.runCommand({
-      sandboxId: this.sandboxId,
-      command: params.cmd,
-      args: params.args ?? [],
-      cwd: params.cwd,
-      env: params.env ?? {},
-    });
-
-    return new Command({
-      client: this.client,
-      sandboxId: this.sandboxId,
-      cmdId: commandResponse.json.cmdId,
-    });
-  }
-
-  /**
-   * Write files to the filesystem of this sandbox.
-   */
-  async writeFiles(files: { path: string; stream: Readable | Buffer }[]) {
-    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: number): string {
-    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}`);
-    }
-  }
-}
-
-/**
- * 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
- */
-export class Command {
-  private client: SandboxClient;
-  private sandboxId: string;
-  /**
-   * ID of the command execution.
-   */
-  public cmdId: string;
-  /**
-   * The exit code of the command, if available. This is set after
-   * {@link wait} has returned.
-   */
-  public exitCode: number | null;
-
-  constructor({
-    client,
-    sandboxId,
-    cmdId,
-  }: {
-    client: SandboxClient;
-    sandboxId: string;
-    cmdId: string;
-  }) {
-    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: "stdout" | "stderr" | "both" = "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");
-  }
-}

package/src/utils/deferred-generator.ts

@@ -1,38 +0,0 @@
-import { Deferred } from "./deferred";
-
-export interface DeferredGenerator<T, R> {
-  generator(): AsyncGenerator<T, R, void>;
-  next: (value: IteratorResult<T | Promise<T>>) => void;
-}
-
-export function createDeferredGenerator<T, R>(): DeferredGenerator<T, R> {
-  const deferreds = [new Deferred<IteratorResult<Promise<T> | T>>()];
-  let currentIndex = 0;
-
-  const next = (value: IteratorResult<T | Promise<T>, R>) => {
-    const currentDeferred = deferreds[currentIndex];
-    if (!value.done) {
-      deferreds.push(new Deferred<IteratorResult<Promise<T> | T>>());
-      currentIndex++;
-    }
-
-    currentDeferred.resolve(value);
-  };
-
-  function generator(): AsyncGenerator<T, R> {
-    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/src/utils/deferred.ts

@@ -1,12 +0,0 @@
-export class Deferred<T> {
-  promise: Promise<T>;
-  resolve!: (value: T | PromiseLike<T>) => void;
-  reject!: (reason?: any) => void;
-
-  constructor() {
-    this.promise = new Promise((res, rej) => {
-      this.resolve = res;
-      this.reject = rej;
-    });
-  }
-}