@cloudflare/sandbox 0.3.7 → 0.4.1

package/src/errors.ts

@@ -1,219 +0,0 @@
-/**
- * Standard error response from the sandbox API
- */
-export interface SandboxErrorResponse {
-  error?: string;
-  status?: string;
-  progress?: number;
-}
-
-/**
- * Base error class for all Sandbox-related errors
- */
-export class SandboxError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = this.constructor.name;
-
-    // Maintains proper stack trace for where our error was thrown (only available on V8)
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-}
-
-/**
- * Error thrown when interpreter functionality is requested but the service is still initializing.
- *
- * Note: With the current implementation, requests wait for interpreter to be ready.
- * This error is only thrown when:
- * 1. The request times out waiting for interpreter (default: 30 seconds)
- * 2. interpreter initialization actually fails
- *
- * Most requests will succeed after a delay, not throw this error.
- */
-export class InterpreterNotReadyError extends SandboxError {
-  public readonly code = "INTERPRETER_NOT_READY";
-  public readonly retryAfter: number;
-  public readonly progress?: number;
-
-  constructor(
-    message?: string,
-    options?: { retryAfter?: number; progress?: number }
-  ) {
-    super(
-      message ||
-        "Interpreter is still initializing. Please retry in a few seconds."
-    );
-    this.retryAfter = options?.retryAfter || 5;
-    this.progress = options?.progress;
-  }
-}
-
-/**
- * Error thrown when a context is not found
- */
-export class ContextNotFoundError extends SandboxError {
-  public readonly code = "CONTEXT_NOT_FOUND";
-  public readonly contextId: string;
-
-  constructor(contextId: string) {
-    super(`Context ${contextId} not found`);
-    this.contextId = contextId;
-  }
-}
-
-/**
- * Error thrown when code execution fails
- */
-export class CodeExecutionError extends SandboxError {
-  public readonly code = "CODE_EXECUTION_ERROR";
-  public readonly executionError?: {
-    ename?: string;
-    evalue?: string;
-    traceback?: string[];
-  };
-
-  constructor(message: string, executionError?: any) {
-    super(message);
-    this.executionError = executionError;
-  }
-}
-
-/**
- * Error thrown when the sandbox container is not ready
- */
-export class ContainerNotReadyError extends SandboxError {
-  public readonly code = "CONTAINER_NOT_READY";
-
-  constructor(message?: string) {
-    super(
-      message ||
-        "Container is not ready. Please wait for initialization to complete."
-    );
-  }
-}
-
-/**
- * Error thrown when a network request to the sandbox fails
- */
-export class SandboxNetworkError extends SandboxError {
-  public readonly code = "NETWORK_ERROR";
-  public readonly statusCode?: number;
-  public readonly statusText?: string;
-
-  constructor(message: string, statusCode?: number, statusText?: string) {
-    super(message);
-    this.statusCode = statusCode;
-    this.statusText = statusText;
-  }
-}
-
-/**
- * Error thrown when service is temporarily unavailable (e.g., circuit breaker open)
- */
-export class ServiceUnavailableError extends SandboxError {
-  public readonly code = "SERVICE_UNAVAILABLE";
-  public readonly retryAfter?: number;
-
-  constructor(message?: string, retryAfter?: number) {
-    // Simple, user-friendly message without implementation details
-    super(message || "Service temporarily unavailable");
-    this.retryAfter = retryAfter;
-  }
-}
-
-/**
- * Type guard to check if an error is a InterpreterNotReadyError
- */
-export function isInterpreterNotReadyError(
-  error: unknown
-): error is InterpreterNotReadyError {
-  return error instanceof InterpreterNotReadyError;
-}
-
-/**
- * Type guard to check if an error is any SandboxError
- */
-export function isSandboxError(error: unknown): error is SandboxError {
-  return error instanceof SandboxError;
-}
-
-/**
- * Helper to determine if an error is retryable
- */
-export function isRetryableError(error: unknown): boolean {
-  if (
-    error instanceof InterpreterNotReadyError ||
-    error instanceof ContainerNotReadyError ||
-    error instanceof ServiceUnavailableError
-  ) {
-    return true;
-  }
-
-  if (error instanceof SandboxNetworkError) {
-    // Retry on 502, 503, 504 (gateway/service unavailable errors)
-    return error.statusCode
-      ? [502, 503, 504].includes(error.statusCode)
-      : false;
-  }
-
-  return false;
-}
-
-/**
- * Parse error response from the sandbox API and return appropriate error instance
- */
-export async function parseErrorResponse(
-  response: Response
-): Promise<SandboxError> {
-  let data: SandboxErrorResponse;
-
-  try {
-    data = (await response.json()) as SandboxErrorResponse;
-  } catch {
-    // If JSON parsing fails, return a generic network error
-    return new SandboxNetworkError(
-      `Request failed with status ${response.status}`,
-      response.status,
-      response.statusText
-    );
-  }
-
-  // Check for specific error types based on response
-  if (response.status === 503) {
-    // Circuit breaker error
-    if (data.status === "circuit_open") {
-      return new ServiceUnavailableError(
-        "Service temporarily unavailable",
-        parseInt(response.headers.get("Retry-After") || "30")
-      );
-    }
-
-    // Interpreter initialization error
-    if (data.status === "initializing") {
-      return new InterpreterNotReadyError(data.error, {
-        retryAfter: parseInt(response.headers.get("Retry-After") || "5"),
-        progress: data.progress,
-      });
-    }
-  }
-
-  // Check for context not found
-  if (
-    response.status === 404 &&
-    data.error?.includes("Context") &&
-    data.error?.includes("not found")
-  ) {
-    const contextId =
-      data.error.match(/Context (\S+) not found/)?.[1] || "unknown";
-    return new ContextNotFoundError(contextId);
-  }
-
-  // Default network error
-  return new SandboxNetworkError(
-    data.error || `Request failed with status ${response.status}`,
-    response.status,
-    response.statusText
-  );
-}

package/src/interpreter-types.ts

@@ -1,390 +0,0 @@
-// Context Management
-export interface CreateContextOptions {
-  /**
-   * Programming language for the context
-   * @default 'python'
-   */
-  language?: "python" | "javascript" | "typescript";
-
-  /**
-   * Working directory for the context
-   * @default '/workspace'
-   */
-  cwd?: string;
-
-  /**
-   * Environment variables for the context
-   */
-  envVars?: Record<string, string>;
-
-  /**
-   * Request timeout in milliseconds
-   * @default 30000
-   */
-  timeout?: number;
-}
-
-export interface CodeContext {
-  /**
-   * Unique identifier for the context
-   */
-  readonly id: string;
-
-  /**
-   * Programming language of the context
-   */
-  readonly language: string;
-
-  /**
-   * Current working directory
-   */
-  readonly cwd: string;
-
-  /**
-   * When the context was created
-   */
-  readonly createdAt: Date;
-
-  /**
-   * When the context was last used
-   */
-  readonly lastUsed: Date;
-}
-
-// Execution Options
-export interface RunCodeOptions {
-  /**
-   * Context to run the code in. If not provided, uses default context for the language
-   */
-  context?: CodeContext;
-
-  /**
-   * Language to use if context is not provided
-   * @default 'python'
-   */
-  language?: "python" | "javascript" | "typescript";
-
-  /**
-   * Environment variables for this execution
-   */
-  envVars?: Record<string, string>;
-
-  /**
-   * Execution timeout in milliseconds
-   * @default 60000
-   */
-  timeout?: number;
-
-  /**
-   * AbortSignal for cancelling execution
-   */
-  signal?: AbortSignal;
-
-  /**
-   * Callback for stdout output
-   */
-  onStdout?: (output: OutputMessage) => void | Promise<void>;
-
-  /**
-   * Callback for stderr output
-   */
-  onStderr?: (output: OutputMessage) => void | Promise<void>;
-
-  /**
-   * Callback for execution results (charts, tables, etc)
-   */
-  onResult?: (result: Result) => void | Promise<void>;
-
-  /**
-   * Callback for execution errors
-   */
-  onError?: (error: ExecutionError) => void | Promise<void>;
-}
-
-// Output Messages
-export interface OutputMessage {
-  /**
-   * The output text
-   */
-  text: string;
-
-  /**
-   * Timestamp of the output
-   */
-  timestamp: number;
-}
-
-// Execution Results
-export interface Result {
-  /**
-   * Plain text representation
-   */
-  text?: string;
-
-  /**
-   * HTML representation (tables, formatted output)
-   */
-  html?: string;
-
-  /**
-   * PNG image data (base64 encoded)
-   */
-  png?: string;
-
-  /**
-   * JPEG image data (base64 encoded)
-   */
-  jpeg?: string;
-
-  /**
-   * SVG image data
-   */
-  svg?: string;
-
-  /**
-   * LaTeX representation
-   */
-  latex?: string;
-
-  /**
-   * Markdown representation
-   */
-  markdown?: string;
-
-  /**
-   * JavaScript code to execute
-   */
-  javascript?: string;
-
-  /**
-   * JSON data
-   */
-  json?: any;
-
-  /**
-   * Chart data if the result is a visualization
-   */
-  chart?: ChartData;
-
-  /**
-   * Raw data object
-   */
-  data?: any;
-
-  /**
-   * Available output formats
-   */
-  formats(): string[];
-}
-
-// Chart Data
-export interface ChartData {
-  /**
-   * Type of chart
-   */
-  type:
-    | "line"
-    | "bar"
-    | "scatter"
-    | "pie"
-    | "histogram"
-    | "heatmap"
-    | "unknown";
-
-  /**
-   * Chart title
-   */
-  title?: string;
-
-  /**
-   * Chart data (format depends on library)
-   */
-  data: any;
-
-  /**
-   * Chart layout/configuration
-   */
-  layout?: any;
-
-  /**
-   * Additional configuration
-   */
-  config?: any;
-
-  /**
-   * Library that generated the chart
-   */
-  library?: "matplotlib" | "plotly" | "altair" | "seaborn" | "unknown";
-
-  /**
-   * Base64 encoded image if available
-   */
-  image?: string;
-}
-
-// Execution Error
-export interface ExecutionError {
-  /**
-   * Error name/type (e.g., 'NameError', 'SyntaxError')
-   */
-  name: string;
-
-  /**
-   * Error message
-   */
-  value: string;
-
-  /**
-   * Stack trace
-   */
-  traceback: string[];
-
-  /**
-   * Line number where error occurred
-   */
-  lineNumber?: number;
-}
-
-// Serializable execution result
-export interface ExecutionResult {
-  code: string;
-  logs: {
-    stdout: string[];
-    stderr: string[];
-  };
-  error?: ExecutionError;
-  executionCount?: number;
-  results: Array<{
-    text?: string;
-    html?: string;
-    png?: string;
-    jpeg?: string;
-    svg?: string;
-    latex?: string;
-    markdown?: string;
-    javascript?: string;
-    json?: any;
-    chart?: ChartData;
-    data?: any;
-  }>;
-}
-
-// Execution Result Container
-export class Execution {
-  /**
-   * All results from the execution
-   */
-  public results: Result[] = [];
-
-  /**
-   * Accumulated stdout and stderr
-   */
-  public logs = {
-    stdout: [] as string[],
-    stderr: [] as string[],
-  };
-
-  /**
-   * Execution error if any
-   */
-  public error?: ExecutionError;
-
-  /**
-   * Execution count (for interpreter)
-   */
-  public executionCount?: number;
-
-  constructor(
-    public readonly code: string,
-    public readonly context: CodeContext
-  ) {}
-
-  /**
-   * Convert to a plain object for serialization
-   */
-  toJSON(): ExecutionResult {
-    return {
-      code: this.code,
-      logs: this.logs,
-      error: this.error,
-      executionCount: this.executionCount,
-      results: this.results.map((result) => ({
-        text: result.text,
-        html: result.html,
-        png: result.png,
-        jpeg: result.jpeg,
-        svg: result.svg,
-        latex: result.latex,
-        markdown: result.markdown,
-        javascript: result.javascript,
-        json: result.json,
-        chart: result.chart,
-        data: result.data,
-      })),
-    };
-  }
-}
-
-// Implementation of Result
-export class ResultImpl implements Result {
-  constructor(private raw: any) {}
-
-  get text(): string | undefined {
-    return this.raw.text || this.raw.data?.["text/plain"];
-  }
-
-  get html(): string | undefined {
-    return this.raw.html || this.raw.data?.["text/html"];
-  }
-
-  get png(): string | undefined {
-    return this.raw.png || this.raw.data?.["image/png"];
-  }
-
-  get jpeg(): string | undefined {
-    return this.raw.jpeg || this.raw.data?.["image/jpeg"];
-  }
-
-  get svg(): string | undefined {
-    return this.raw.svg || this.raw.data?.["image/svg+xml"];
-  }
-
-  get latex(): string | undefined {
-    return this.raw.latex || this.raw.data?.["text/latex"];
-  }
-
-  get markdown(): string | undefined {
-    return this.raw.markdown || this.raw.data?.["text/markdown"];
-  }
-
-  get javascript(): string | undefined {
-    return this.raw.javascript || this.raw.data?.["application/javascript"];
-  }
-
-  get json(): any {
-    return this.raw.json || this.raw.data?.["application/json"];
-  }
-
-  get chart(): ChartData | undefined {
-    return this.raw.chart;
-  }
-
-  get data(): any {
-    return this.raw.data;
-  }
-
-  formats(): string[] {
-    const formats: string[] = [];
-    if (this.text) formats.push("text");
-    if (this.html) formats.push("html");
-    if (this.png) formats.push("png");
-    if (this.jpeg) formats.push("jpeg");
-    if (this.svg) formats.push("svg");
-    if (this.latex) formats.push("latex");
-    if (this.markdown) formats.push("markdown");
-    if (this.javascript) formats.push("javascript");
-    if (this.json) formats.push("json");
-    if (this.chart) formats.push("chart");
-    return formats;
-  }
-}