@vercel/sandbox 1.1.9 → 1.2.1

package/src/api-client/base-client.ts

@@ -1,171 +0,0 @@
-import type { Options as RetryOptions } from "async-retry";
-import { APIError } from "./api-error";
-import { ZodType } from "zod";
-import { array } from "../utils/array";
-import { withRetry, type RequestOptions } from "./with-retry";
-import { Agent } from "undici";
-
-export interface RequestParams extends RequestInit {
-  headers?: Record<string, string>;
-  method?: string;
-  onRetry?(error: any, options: RequestOptions): void;
-  query?: Record<string, number | string | null | undefined | string[]>;
-  retry?: Partial<RetryOptions>;
-}
-
-/**
- * A base API client that provides a convenience wrapper for fetching where
- * we can pass query parameters as an object, support retries, debugging
- * and automatic authorization.
- */
-export class BaseClient {
-  protected token?: string;
-  private fetch: ReturnType<typeof withRetry<RequestInit>>;
-  private debug: boolean;
-  private baseUrl: string;
-  private agent: Agent;
-
-  constructor(params: {
-    debug?: boolean;
-    baseUrl: string;
-    token?: string;
-    fetch?: typeof globalThis.fetch;
-  }) {
-    this.fetch = withRetry(params.fetch ?? globalThis.fetch);
-    this.baseUrl = params.baseUrl;
-    this.debug = params.debug ?? process.env.DEBUG_FETCH === "true";
-    this.token = params.token;
-    this.agent = new Agent({
-      bodyTimeout: 0, // disable body timeout to allow long logs streaming
-    });
-  }
-
-  protected async request(path: string, opts?: RequestParams) {
-    const url = new URL(`${this.baseUrl}${path}`);
-    if (opts?.query) {
-      for (const [key, value] of Object.entries(opts.query)) {
-        array(value).forEach((value) => {
-          url.searchParams.append(key, value.toString());
-        });
-      }
-    }
-
-    const start = Date.now();
-    const response = await this.fetch(url.toString(), {
-      ...opts,
-      body: opts?.body,
-      method: opts?.method || "GET",
-      headers: this.token
-        ? { Authorization: `Bearer ${this.token}`, ...opts?.headers }
-        : opts?.headers,
-      // @ts-expect-error Node.js' and undici's Agent have different types
-      dispatcher: this.agent,
-      signal: opts?.signal,
-    });
-
-    if (this.debug) {
-      const duration = Date.now() - start;
-      console.log(`[API] ${url} (${response.status}) ${duration}ms`);
-      if (response.status === 429) {
-        const retry = parseInt(response.headers.get("Retry-After") ?? "", 10);
-        const hours = Math.floor(retry / 60 / 60);
-        const minutes = Math.floor(retry / 60) % 60;
-        const seconds = retry % 60;
-        console.warn(
-          `[API] ${url} Rate Limited, Retry After ${hours}h ${minutes}m ${seconds}s`,
-        );
-      }
-    }
-
-    return response;
-  }
-}
-
-export interface Parsed<Data> {
-  response: Response;
-  text: string;
-  json: Data;
-}
-
-/**
- * Extract sandboxId from a sandbox API URL.
- * URLs follow the pattern: /v1/sandboxes/{sandboxId}/...
- */
-function extractSandboxId(url: string): string | undefined {
-  const match = url.match(/\/v1\/sandboxes\/([^/?]+)/);
-  return match?.[1];
-}
-
-/**
- * Allows to read the response text and parse it as JSON casting to the given
- * type. If the response is not ok or cannot be parsed it will return error.
- *
- * @param response Response to parse.
- * @returns Parsed response or error.
- */
-export async function parse<Data, ErrorData>(
-  validator: ZodType<Data>,
-  response: Response,
-): Promise<Parsed<Data> | APIError<ErrorData>> {
-  const sandboxId = extractSandboxId(response.url);
-
-  const text = await response.text().catch((err) => {
-    return new APIError<ErrorData>(response, {
-      message: `Can't read response text: ${String(err)}`,
-      sandboxId,
-    });
-  });
-
-  if (typeof text !== "string") {
-    return text;
-  }
-
-  let json: Data | ErrorData;
-
-  try {
-    json = JSON.parse(text || "{}");
-  } catch (error) {
-    return new APIError<ErrorData>(response, {
-      message: `Can't parse JSON: ${String(error)}`,
-      text,
-      sandboxId,
-    });
-  }
-
-  if (!response.ok) {
-    return new APIError<ErrorData>(response, {
-      message: `Status code ${response.status} is not ok`,
-      json: json as ErrorData,
-      text,
-      sandboxId,
-    });
-  }
-
-  const validated = validator.safeParse(json);
-  if (!validated.success) {
-    return new APIError<ErrorData>(response, {
-      message: `Response JSON is not valid: ${validated.error}`,
-      json: json as ErrorData,
-      text,
-      sandboxId,
-    });
-  }
-
-  return {
-    json: validated.data,
-    response,
-    text,
-  };
-}
-
-export async function parseOrThrow<Data, ErrorData>(
-  validator: ZodType<Data>,
-  response: Response,
-): Promise<Parsed<Data>> {
-  const result = await parse<Data, ErrorData>(validator, response);
-  if (result instanceof APIError) {
-    throw result;
-  }
-
-  return result;
-}

package/src/api-client/file-writer.ts

@@ -1,90 +0,0 @@
-import zlib from "zlib";
-import tar, { type Pack } from "tar-stream";
-import { Readable } from "stream";
-
-interface FileBuffer {
-  /**
-   * The name (path) of the file to write.
-   */
-  name: string;
-  /**
-   * The content of the file as a Buffer.
-   */
-  content: Buffer;
-}
-
-interface FileStream {
-  /**
-   * The name (path) of the file to write.
-   */
-  name: string;
-  /**
-   * A Readable stream to consume the content of the file.
-   */
-  content: Readable;
-  /**
-   * The expected size of the file. This is required to write
-   * the header of the compressed file.
-   */
-  size: number;
-}
-
-/**
- * Allows to create a Readable stream with methods to write files
- * to it and to finish it. Files written are compressed together
- * and gzipped in the stream.
- */
-export class FileWriter {
-  public readable: Readable;
-  private pack: Pack;
-
-  constructor() {
-    const gzip = zlib.createGzip();
-    this.pack = tar.pack();
-    this.readable = this.pack.pipe(gzip);
-  }
-
-  /**
-   * Allows to add a file to the stream. Size is required to write
-   * the tarball header so when content is a stream it must be
-   * provided.
-   *
-   * Returns a Promise resolved once the file is written in the
-   * stream.
-   */
-  async addFile(file: FileBuffer | FileStream) {
-    return new Promise<void>((resolve, reject) => {
-      const entry = this.pack.entry(
-        "size" in file
-          ? { name: file.name, size: file.size }
-          : { name: file.name, size: file.content.length },
-        (error) => {
-          if (error) {
-            return reject(error);
-          } else {
-            resolve();
-          }
-        },
-      );
-
-      if (file.content instanceof Readable) {
-        file.content.pipe(entry);
-      } else {
-        entry.end(file.content);
-      }
-    });
-  }
-
-  /**
-   * Allows to finish the stream returning a Promise that will
-   * resolve once the readable is effectively closed or
-   * errored.
-   */
-  async end() {
-    return new Promise<void>((resolve, reject) => {
-      this.readable.on("error", reject);
-      this.readable.on("end", resolve);
-      this.pack.finalize();
-    });
-  }
-}

package/src/api-client/index.ts

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

package/src/api-client/validators.ts

@@ -1,144 +0,0 @@
-import { z } from "zod";
-
-export type SandboxMetaData = z.infer<typeof Sandbox>;
-
-export const Sandbox = z.object({
-  id: z.string(),
-  memory: z.number(),
-  vcpus: z.number(),
-  region: z.string(),
-  runtime: z.string(),
-  timeout: z.number(),
-  status: z.enum([
-    "pending",
-    "running",
-    "stopping",
-    "stopped",
-    "failed",
-    "snapshotting",
-  ]),
-  requestedAt: z.number(),
-  startedAt: z.number().optional(),
-  requestedStopAt: z.number().optional(),
-  stoppedAt: z.number().optional(),
-  duration: z.number().optional(),
-  sourceSnapshotId: z.string().optional(),
-  snapshottedAt: z.number().optional(),
-  createdAt: z.number(),
-  cwd: z.string(),
-  updatedAt: z.number(),
-  interactivePort: z.number().optional(),
-});
-
-export type SandboxRouteData = z.infer<typeof SandboxRoute>;
-
-export const SandboxRoute = z.object({
-  url: z.string(),
-  subdomain: z.string(),
-  port: z.number(),
-});
-
-export type SnapshotMetadata = z.infer<typeof Snapshot>;
-
-export const Snapshot = z.object({
-  id: z.string(),
-  sourceSandboxId: z.string(),
-  region: z.string(),
-  status: z.enum(["created", "deleted", "failed"]),
-  sizeBytes: z.number(),
-  expiresAt: z.number(),
-  createdAt: z.number(),
-  updatedAt: z.number(),
-});
-
-export const Pagination = z.object({
-  /**
-   * Amount of items in the current page.
-   * @example 20
-   */
-  count: z.number(),
-  /**
-   * Timestamp that must be used to request the next page.
-   * @example 1540095775951
-   */
-  next: z.number().nullable(),
-  /**
-   * Timestamp that must be used to request the previous page.
-   * @example 1540095775951
-   */
-  prev: z.number().nullable(),
-});
-
-export type CommandData = z.infer<typeof Command>;
-
-export const Command = z.object({
-  id: z.string(),
-  name: z.string(),
-  args: z.array(z.string()),
-  cwd: z.string(),
-  sandboxId: z.string(),
-  exitCode: z.number().nullable(),
-  startedAt: z.number(),
-});
-
-const CommandFinished = Command.extend({
-  exitCode: z.number(),
-});
-
-export const SandboxResponse = z.object({
-  sandbox: Sandbox,
-});
-
-export const SandboxAndRoutesResponse = SandboxResponse.extend({
-  routes: z.array(SandboxRoute),
-});
-
-export const CommandResponse = z.object({
-  command: Command,
-});
-
-export const CommandFinishedResponse = z.object({
-  command: CommandFinished,
-});
-
-export const EmptyResponse = z.object({});
-
-const LogLineBase = z.object({ data: z.string() });
-export const LogLineStdout = LogLineBase.extend({
-  stream: z.literal("stdout"),
-});
-export const LogLineStderr = LogLineBase.extend({
-  stream: z.literal("stderr"),
-});
-
-export const LogError = z.object({
-  stream: z.literal("error"),
-  data: z.object({
-    code: z.string(),
-    message: z.string(),
-  }),
-});
-
-export const LogLine = z.discriminatedUnion("stream", [
-  LogLineStdout,
-  LogLineStderr,
-  LogError,
-]);
-
-export const SandboxesResponse = z.object({
-  sandboxes: z.array(Sandbox),
-  pagination: Pagination,
-});
-
-export const ExtendTimeoutResponse = z.object({
-  sandbox: Sandbox,
-});
-
-export const CreateSnapshotResponse = z.object({
-  snapshot: Snapshot,
-  sandbox: Sandbox,
-});
-
-export const SnapshotResponse = z.object({
-  snapshot: Snapshot,
-});

package/src/api-client/with-retry.ts

@@ -1,131 +0,0 @@
-import type { Options as RetryOptions } from "async-retry";
-import { APIError } from "./api-error";
-import { setTimeout } from "node:timers/promises";
-import retry from "async-retry";
-
-export interface RequestOptions {
-  onRetry?(error: any, options: RequestOptions): void;
-  retry?: Partial<RetryOptions>;
-}
-
-/**
- * Wraps a fetch function with retry logic. The retry logic will retry
- * on network errors, 429 responses and 5xx responses. The retry logic
- * will not retry on 4xx responses.
- *
- * @param rawFetch The fetch function to wrap.
- * @returns The wrapped fetch function.
- */
-export function withRetry<T extends RequestInit>(
-  rawFetch: (url: URL | string, init?: T) => Promise<Response>,
-) {
-  return async (
-    url: URL | string,
-    opts: T & RequestOptions = <T & RequestOptions>{},
-  ) => {
-    /**
-     * Timeouts by default will be [10, 60, 360, 2160, 12960]
-     * before randomization is added.
-     */
-    const retryOpts = Object.assign(
-      {
-        minTimeout: 10,
-        retries: 5,
-        factor: 6,
-        maxRetryAfter: 20,
-      },
-      opts.retry,
-    );
-
-    if (opts.onRetry) {
-      retryOpts.onRetry = (error, attempts) => {
-        opts.onRetry!(error, opts);
-        if (opts.retry && opts.retry.onRetry) {
-          opts.retry.onRetry(error, attempts);
-        }
-      };
-    }
-
-    try {
-      return (await retry(async (bail) => {
-        try {
-          if (opts.signal?.aborted) {
-            return bail(opts.signal.reason || new Error("Request aborted"));
-          }
-          const response = await rawFetch(url, opts);
-
-          /**
-           * When the response is 429 we will try to parse the Retry-After
-           * header. If the header exists we will try to parse it and, if
-           * the wait time is higher than the maximum defined, we respond.
-           * Otherwise we wait for the time given in the header and throw
-           * to retry.
-           */
-          if (response.status === 429) {
-            const retryAfter = parseInt(
-              response.headers.get("retry-after") || "",
-              10,
-            );
-
-            if (retryAfter && !isNaN(retryAfter)) {
-              if (retryAfter > retryOpts.maxRetryAfter) {
-                return response;
-              }
-
-              await setTimeout(retryAfter * 1e3);
-            }
-
-            throw new APIError(response);
-          }
-
-          /**
-           * If the response is a a retryable error, we throw in
-           * order to retry.
-           */
-          if (response.status >= 500 && response.status < 600) {
-            throw new APIError(response);
-          }
-
-          return response;
-        } catch (error) {
-          /**
-           * If the request was aborted using the AbortController
-           * we bail from retrying throwing the original error.
-           */
-          if (isAbortError(error)) {
-            return bail(error);
-          }
-
-          /**
-           * If the signal was aborted meanwhile we were
-           * waiting, we bail from retrying.
-           */
-          if (opts.signal?.aborted) {
-            return bail(opts.signal.reason || new Error("Request aborted"));
-          }
-
-          throw error;
-        }
-      }, retryOpts)) as Response;
-    } catch (error) {
-      /**
-       * The ResponseError is only intended for retries so in case we
-       * ran out of attempts we will respond with the last response
-       * we obtained.
-       */
-      if (error instanceof APIError) {
-        return error.response;
-      }
-
-      throw error;
-    }
-  };
-}
-
-function isAbortError(error: unknown): error is Error {
-  return (
-    error !== undefined &&
-    error !== null &&
-    (error as Error).name === "AbortError"
-  );
-}

package/src/auth/api.ts

@@ -1,31 +0,0 @@
-import { NotOk } from "./error";
-
-export async function fetchApi(opts: {
-  token: string;
-  endpoint: string;
-  method?: string;
-  body?: string;
-}): Promise<unknown> {
-  const x = await fetch(`https://api.vercel.com${opts.endpoint}`, {
-    method: opts.method,
-    body: opts.body,
-    headers: {
-      Authorization: `Bearer ${opts.token}`,
-      "Content-Type": "application/json",
-    },
-  });
-  if (!x.ok) {
-    let message = await x.text();
-
-    try {
-      const { error } = JSON.parse(message);
-      message = `${error.code.toUpperCase()}: ${error.message}`;
-    } catch {}
-
-    throw new NotOk({
-      responseText: message,
-      statusCode: x.status,
-    });
-  }
-  return (await x.json()) as unknown;
-}

package/src/auth/error.ts

@@ -1,8 +0,0 @@
-export class NotOk extends Error {
-  name = "NotOk";
-  response: { statusCode: number; responseText: string };
-  constructor(response: { statusCode: number; responseText: string }) {
-    super(`HTTP ${response.statusCode}: ${response.responseText}`);
-    this.response = response;
-  }
-}

package/src/auth/file.ts

@@ -1,69 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import { homedir } from "node:os";
-import XDGAppPaths from "xdg-app-paths";
-import { z } from "zod";
-import { json } from "./zod";
-
-const ZodDate = z.number().transform((seconds) => new Date(seconds * 1000));
-
-const AuthFile = z.object({
-  token: z.string().min(1).optional(),
-  refreshToken: z.string().min(1).optional(),
-  expiresAt: ZodDate.optional(),
-});
-
-const StoredAuthFile = json.pipe(AuthFile);
-
-type AuthFile = z.infer<typeof AuthFile>;
-
-// Returns whether a directory exists
-const isDirectory = (path: string): boolean => {
-  try {
-    return fs.lstatSync(path).isDirectory();
-  } catch (_) {
-    // We don't care which kind of error occured, it isn't a directory anyway.
-    return false;
-  }
-};
-
-// Returns in which directory the config should be present
-const getGlobalPathConfig = (): string => {
-  const vercelDirectories = XDGAppPaths("com.vercel.cli").dataDirs();
-
-  const possibleConfigPaths = [
-    ...vercelDirectories, // latest vercel directory
-    path.join(homedir(), ".now"), // legacy config in user's home directory
-    ...XDGAppPaths("now").dataDirs(), // legacy XDG directory
-  ];
-
-  // The customPath flag is the preferred location,
-  // followed by the vercel directory,
-  // followed by the now directory.
-  // If none of those exist, use the vercel directory.
-  return (
-    possibleConfigPaths.find((configPath) => isDirectory(configPath)) ||
-    vercelDirectories[0]
-  );
-};
-
-export const getAuth = () => {
-  try {
-    const pathname = path.join(getGlobalPathConfig(), "auth.json");
-    return StoredAuthFile.parse(fs.readFileSync(pathname, "utf8"));
-  } catch {
-    return null;
-  }
-};
-
-export function updateAuthConfig(config: AuthFile): void {
-  const pathname = path.join(getGlobalPathConfig(), "auth.json");
-  fs.mkdirSync(path.dirname(pathname), { recursive: true });
-  const content = {
-    token: config.token,
-    expiresAt:
-      config.expiresAt && Math.round(config.expiresAt.getTime() / 1000),
-    refreshToken: config.refreshToken,
-  } satisfies z.input<typeof AuthFile>;
-  fs.writeFileSync(pathname, JSON.stringify(content) + "\n");
-}

package/src/auth/index.ts

@@ -1,9 +0,0 @@
-// This file can also be imported as `@vercel/sandbox/dist/auth`, which is completely fine.
-// The only valid importer of this would be the CLI as we share the same codebase.
-
-export * from "./file";
-export type * from "./file";
-export * from "./oauth";
-export type * from "./oauth";
-export { pollForToken } from "./poll-for-token";
-export { inferScope, selectTeam } from "./project";