eve 0.12.0 → 0.12.2

package/dist/src/compiled/@vercel/sandbox/filesystem.d.ts

@@ -0,0 +1,258 @@
+import { Dirent, Stats } from "fs";
+
+//#region src/filesystem.d.ts
+type WriteFileData = string | Buffer | Uint8Array;
+interface MkdirOptions {
+  recursive?: boolean;
+  signal?: AbortSignal;
+}
+interface RmOptions {
+  recursive?: boolean;
+  force?: boolean;
+  signal?: AbortSignal;
+}
+interface SandboxHandle {
+  readFileToBuffer(file: {
+    path: string;
+  }, opts?: {
+    signal?: AbortSignal;
+  }): Promise<Buffer | null>;
+  writeFiles(files: {
+    path: string;
+    content: Buffer;
+  }[], opts?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  mkDir(path: string, opts?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  runCommand(cmd: string, args?: string[], opts?: {
+    signal?: AbortSignal;
+  }): Promise<{
+    exitCode: number;
+    stdout(opts?: {
+      signal?: AbortSignal;
+    }): Promise<string>;
+    stderr(opts?: {
+      signal?: AbortSignal;
+    }): Promise<string>;
+  }>;
+}
+declare class FileSystem {
+  /** @internal */
+  private sandbox;
+  /** @internal */
+  constructor(sandbox: SandboxHandle);
+  /**
+   * Read the entire contents of a file.
+   *
+   * @param path - Path to the file
+   * @param options - Encoding or options object. If encoding is specified, returns a string; otherwise returns a Buffer.
+   */
+  readFile(path: string, options?: {
+    encoding?: null;
+    signal?: AbortSignal;
+  } | null): Promise<Buffer>;
+  readFile(path: string, options: {
+    encoding: BufferEncoding;
+    signal?: AbortSignal;
+  } | BufferEncoding): Promise<string>;
+  /**
+   * Write data to a file, replacing the file if it already exists.
+   *
+   * @param path - Path to the file
+   * @param data - The data to write
+   * @param options - Write options
+   */
+  writeFile(path: string, data: WriteFileData, options?: {
+    encoding?: BufferEncoding;
+    signal?: AbortSignal;
+  } | BufferEncoding): Promise<void>;
+  /**
+   * Append data to a file, creating the file if it does not yet exist.
+   *
+   * @param path - Path to the file
+   * @param data - The data to append
+   * @param options - Write options
+   */
+  appendFile(path: string, data: WriteFileData, options?: {
+    encoding?: BufferEncoding;
+    signal?: AbortSignal;
+  } | BufferEncoding): Promise<void>;
+  /**
+   * Create a directory.
+   *
+   * @param path - Path of the directory to create
+   * @param options - Options for directory creation
+   */
+  mkdir(path: string, options?: MkdirOptions | number): Promise<string | undefined>;
+  /**
+   * Read the contents of a directory.
+   *
+   * @param path - Path to the directory
+   * @param options - Options. When `withFileTypes` is true, returns `Dirent` objects.
+   */
+  readdir(path: string, options?: {
+    signal?: AbortSignal;
+    withFileTypes?: false;
+  }): Promise<string[]>;
+  readdir(path: string, options: {
+    signal?: AbortSignal;
+    withFileTypes: true;
+  }): Promise<Dirent[]>;
+  /**
+   * Get file status. Follows symbolic links.
+   *
+   * @param path - Path to the file
+   * @param options - Options
+   */
+  stat(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<Stats>;
+  /**
+   * Get file status. Does not follow symbolic links.
+   *
+   * @param path - Path to the file
+   * @param options - Options
+   */
+  lstat(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<Stats>;
+  /**
+   * Remove a file or symbolic link.
+   *
+   * @param path - Path to the file
+   * @param options - Options
+   */
+  unlink(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Remove files and directories.
+   *
+   * @param path - Path to remove
+   * @param options - Options
+   */
+  rm(path: string, options?: RmOptions): Promise<void>;
+  /**
+   * Remove a directory.
+   *
+   * @param path - Path to the directory
+   * @param options - Options
+   */
+  rmdir(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Rename a file or directory.
+   *
+   * @param oldPath - Current path
+   * @param newPath - New path
+   * @param options - Options
+   */
+  rename(oldPath: string, newPath: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Copy a file.
+   *
+   * @param src - Source path
+   * @param dest - Destination path
+   * @param options - Options
+   */
+  copyFile(src: string, dest: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Test whether a file exists and the user has the specified permissions.
+   *
+   * @param path - Path to the file
+   * @param options - Options
+   */
+  access(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Check if a path exists.
+   *
+   * This is a convenience method not in `node:fs/promises` but commonly needed.
+   *
+   * @param path - Path to check
+   * @param options - Options
+   */
+  exists(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<boolean>;
+  /**
+   * Change file mode (permissions).
+   *
+   * @param path - Path to the file
+   * @param mode - File mode (e.g., 0o755 or "755")
+   * @param options - Options
+   */
+  chmod(path: string, mode: number | string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Change file owner and group.
+   *
+   * @param path - Path to the file
+   * @param uid - User ID
+   * @param gid - Group ID
+   * @param options - Options
+   */
+  chown(path: string, uid: number, gid: number, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Create a symbolic link.
+   *
+   * @param target - The target of the symbolic link
+   * @param path - The path of the symbolic link to create
+   * @param options - Options
+   */
+  symlink(target: string, path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Read the value of a symbolic link.
+   *
+   * @param path - Path to the symbolic link
+   * @param options - Options
+   */
+  readlink(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<string>;
+  /**
+   * Resolve the real path of a file (resolving symlinks).
+   *
+   * @param path - Path to resolve
+   * @param options - Options
+   */
+  realpath(path: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<string>;
+  /**
+   * Truncate a file to a specified length.
+   *
+   * @param path - Path to the file
+   * @param len - Length to truncate to (default: 0)
+   * @param options - Options
+   */
+  truncate(path: string, len?: number, options?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Create a unique temporary directory.
+   *
+   * @param prefix - The prefix for the temporary directory name
+   * @param options - Options
+   * @returns The path of the created temporary directory
+   */
+  mkdtemp(prefix: string, options?: {
+    signal?: AbortSignal;
+  }): Promise<string>;
+}
+//#endregion
+export { FileSystem };
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/src/compiled/@vercel/sandbox/index.d.ts

@@ -1,129 +1,10 @@
-// The firewall network-policy types are copied verbatim from the installed
-// `@vercel/sandbox` at vendor time (see scripts/vendor-compiled/@vercel/sandbox.mjs)
-// so the credential-brokering surface never drifts from the SDK.
-import type { NetworkPolicy } from "./network-policy.js";
-
-export type {
-  NetworkPolicy,
-  NetworkPolicyKeyValueMatcher,
-  NetworkPolicyMatch,
-  NetworkPolicyMatcher,
-  NetworkPolicyRule,
-  NetworkTransformer,
-} from "./network-policy.js";
-
-export interface SandboxKeepLastSnapshotsConfig {
-  count: number;
-  expiration?: number | undefined;
-  deleteEvicted?: boolean | undefined;
-}
-
-export interface SandboxUpdateParams {
-  currentSnapshotId?: string | undefined;
-  keepLastSnapshots?: SandboxKeepLastSnapshotsConfig | null | undefined;
-  networkPolicy?: NetworkPolicy | undefined;
-  persistent?: boolean | undefined;
-  ports?: number[] | undefined;
-  resources?: { vcpus?: number | undefined } | undefined;
-  snapshotExpiration?: number | undefined;
-  tags?: Record<string, string> | undefined;
-  timeout?: number | undefined;
-}
-
-export interface SandboxCreateOptions {
-  [key: `__${string}`]: unknown;
-  env?: Record<string, string> | undefined;
-  name?: string | undefined;
-  networkPolicy?: NetworkPolicy | undefined;
-  onResume?: ((sandbox: Sandbox) => Promise<void>) | undefined;
-  persistent?: boolean | undefined;
-  ports?: number[] | undefined;
-  resources?: { vcpus?: number | undefined } | undefined;
-  runtime?: string | undefined;
-  signal?: AbortSignal | undefined;
-  snapshotExpiration?: number | undefined;
-  source?: unknown;
-  tags?: Record<string, string> | undefined;
-  timeout?: number | undefined;
-}
-
-export interface SandboxGetOptions {
-  name: string;
-  onResume?: ((sandbox: Sandbox) => Promise<void>) | undefined;
-  resume?: boolean | undefined;
-  signal?: AbortSignal | undefined;
-}
-
-export interface SandboxRunCommandParams {
-  args?: readonly string[] | undefined;
-  cmd: string;
-  cwd?: string | undefined;
-  detached?: boolean | undefined;
-  env?: Record<string, string> | undefined;
-  signal?: AbortSignal | undefined;
-  sudo?: boolean | undefined;
-}
-
-export interface SandboxRmOptions {
-  force?: boolean | undefined;
-  recursive?: boolean | undefined;
-  signal?: AbortSignal | undefined;
-}
-
-export declare class FileSystem {
-  rm(path: string, options?: SandboxRmOptions): Promise<void>;
-  unlink(path: string, options?: { signal?: AbortSignal | undefined }): Promise<void>;
-}
-
-export interface SandboxCommandLogMessage {
-  data: string;
-  stream: "stdout" | "stderr";
-}
-
-export declare class SandboxCommand {
-  readonly cmdId: string;
-  readonly cwd: string;
-  exitCode: number | null;
-  logs(opts?: {
-    signal?: AbortSignal | undefined;
-  }): AsyncGenerator<SandboxCommandLogMessage, void, void>;
-  wait(opts?: { signal?: AbortSignal | undefined }): Promise<SandboxCommandFinished>;
-  stdout(opts?: { signal?: AbortSignal | undefined }): Promise<string>;
-  stderr(opts?: { signal?: AbortSignal | undefined }): Promise<string>;
-  kill(signal?: string, opts?: { abortSignal?: AbortSignal | undefined }): Promise<void>;
-}
-
-export interface SandboxCommandFinished extends SandboxCommand {
-  exitCode: number;
-}
-
-export type SandboxCommandResult = SandboxCommandFinished;
-
-export declare class Sandbox {
-  currentSnapshotId?: string | undefined;
-  readonly fs: FileSystem;
-  id: string;
-  name: string;
-  networkPolicy?: NetworkPolicy | undefined;
-  persistent: boolean;
-  status: string;
-  tags?: Record<string, string> | undefined;
-  static create(options?: SandboxCreateOptions): Promise<Sandbox>;
-  static get(options: SandboxGetOptions): Promise<Sandbox>;
-  domain(port: number): string;
-  readFile(file: { path: string }): Promise<ReadableStream<Uint8Array> | null>;
-  readFileToBuffer(file: { path: string }): Promise<Buffer | null>;
-  runCommand(input: SandboxRunCommandParams & { detached: true }): Promise<SandboxCommand>;
-  runCommand(input: SandboxRunCommandParams): Promise<SandboxCommandFinished>;
-  snapshot(options?: unknown): Promise<{ snapshotId: string }>;
-  stop(options?: unknown): Promise<void>;
-  update(
-    params: SandboxUpdateParams,
-    opts?: { signal?: AbortSignal | undefined } | undefined,
-  ): Promise<void>;
-  writeFiles(
-    files: readonly { content: string | Uint8Array; path: string }[],
-    options?: unknown,
-  ): Promise<void>;
-  [key: string]: any;
-}
+import { APIError, StreamError } from "./api-client/api-error.js";
+import { SnapshotTreeNodeData } from "./api-client/validators.js";
+import { NetworkPolicy, NetworkPolicyKeyValueMatcher, NetworkPolicyMatch, NetworkPolicyMatcher, NetworkPolicyRule, NetworkTransformer } from "./network-policy.js";
+import { Command, CommandFinished, CommandOutput, SerializedCommand, SerializedCommandFinished } from "./command.js";
+import { SerializedSnapshot, Snapshot } from "./snapshot.js";
+import { Session } from "./session.js";
+import { FileSystem } from "./filesystem.js";
+import { Sandbox, SerializedSandbox } from "./sandbox.js";
+import { InvalidRequestProxyHandler, ProxyHandler, ProxyMeta, defineSandboxProxy } from "./proxy.js";
+export { APIError, Command, CommandFinished, type CommandOutput, FileSystem, type InvalidRequestProxyHandler, type NetworkPolicy, type NetworkPolicyKeyValueMatcher, type NetworkPolicyMatch, type NetworkPolicyMatcher, type NetworkPolicyRule, type NetworkTransformer, type ProxyHandler, type ProxyMeta, Sandbox, type SerializedCommand, type SerializedCommandFinished, type SerializedSandbox, type SerializedSnapshot, Session, Snapshot, type SnapshotTreeNodeData, StreamError, defineSandboxProxy };

package/dist/src/compiled/@vercel/sandbox/proxy.d.ts

@@ -0,0 +1,55 @@
+//#region src/proxy.d.ts
+interface ProxyMeta {
+  /**
+   * The host of the request as received by this proxy.
+   */
+  host: string;
+  /**
+   * The ID of the team that owns the sandbox that proxied the request.
+   */
+  teamId: string;
+  /**
+   * The ID of the project that owns the sandbox that proxied the request.
+   */
+  projectId: string;
+  /**
+   * The ID of the sandbox that proxied the request.
+   */
+  sandboxId: string;
+  /**
+   * The name of the sandbox that proxied the request, when using persistent sandboxes.
+   */
+  sandboxName: string;
+}
+type ProxyHandler = (request: Request, meta: ProxyMeta) => Response | Promise<Response>;
+type InvalidRequestProxyHandler = (request: Request, error: Error) => Response | Promise<Response>;
+/**
+ * Creates a Web Handler for proxied requests from Vercel Sandboxes using the network policy `forwardURL`
+ * option. The provided `handler` is called for each valid proxied request, with the original request
+ * alongside extracted metadata used to identify the source sandbox and request details.
+ *
+ * This function automatically verifies the OIDC token included in proxied requests to ensure the request
+ * is legitimate: if invalid, the `invalidRequestHandler` is called (by default, a 403 response is returned).
+ *
+ * @example
+ * ```ts
+ * export default {
+ *   fetch: defineSandboxProxy(async (request, meta) => {
+ *     // meta contains the original host & source team/project/sandbox ids
+ *     console.log(meta)
+ *
+ *     // return a custom response, or proxy upstream:
+ *     return await fetch(request)
+ *   }, (request, error) => {
+ *     // optional, handle any authorization error
+ *     return new Response("Forbidden", { status: 403 })
+ *   })
+ * }
+ * ```
+ *
+ * @see https://vercel.com/docs/vercel-sandbox/concepts/firewall#requests-proxying
+ */
+declare function defineSandboxProxy(handler: ProxyHandler, invalidRequestHandler?: InvalidRequestProxyHandler): (request: Request) => Promise<Response>;
+//#endregion
+export { InvalidRequestProxyHandler, ProxyHandler, ProxyMeta, defineSandboxProxy };
+//# sourceMappingURL=proxy.d.ts.map