@cloudflare/sandbox 0.2.0 → 0.2.2

package/src/client.ts

@@ -6,7 +6,7 @@ import type {
   GetProcessResponse,
   ListProcessesResponse,
   StartProcessRequest,
-  StartProcessResponse
+  StartProcessResponse,
 } from "./types";
 
 export interface ExecuteResponse {
@@ -18,22 +18,6 @@ export interface ExecuteResponse {
   timestamp: string;
 }
 
-interface SessionResponse {
-  sessionId: string;
-  message: string;
-  timestamp: string;
-}
-
-interface SessionListResponse {
-  sessions: Array<{
-    sessionId: string;
-    hasActiveProcess: boolean;
-    createdAt: string;
-  }>;
-  count: number;
-  timestamp: string;
-}
-
 interface CommandsResponse {
   availableCommands: string[];
   timestamp: string;
@@ -209,7 +193,7 @@ export class HttpClient {
     this.baseUrl = this.options.baseUrl!;
   }
 
-  private async doFetch(
+  protected async doFetch(
     path: string,
     options?: RequestInit
   ): Promise<Response> {
@@ -252,7 +236,7 @@ export class HttpClient {
 
   async execute(
     command: string,
-    options: Pick<BaseExecOptions, 'sessionId' | 'cwd' | 'env'>
+    options: Pick<BaseExecOptions, "sessionId" | "cwd" | "env">
   ): Promise<ExecuteResponse> {
     try {
       const targetSessionId = options.sessionId || this.sessionId;
@@ -305,7 +289,6 @@ export class HttpClient {
     }
   }
 
-
   async executeCommandStream(
     command: string,
     sessionId?: string
@@ -320,7 +303,7 @@ export class HttpClient {
         }),
         headers: {
           "Content-Type": "application/json",
-          "Accept": "text/event-stream",
+          Accept: "text/event-stream",
         },
         method: "POST",
       });
@@ -338,9 +321,7 @@ export class HttpClient {
         throw new Error("No response body for streaming request");
       }
 
-      console.log(
-        `[HTTP Client] Started command stream: ${command}`
-      );
+      console.log(`[HTTP Client] Started command stream: ${command}`);
 
       return response.body;
     } catch (error) {
@@ -392,7 +373,6 @@ export class HttpClient {
     }
   }
 
-
   async mkdir(
     path: string,
     recursive: boolean = false,
@@ -434,7 +414,6 @@ export class HttpClient {
     }
   }
 
-
   async writeFile(
     path: string,
     content: string,
@@ -478,7 +457,6 @@ export class HttpClient {
     }
   }
 
-
   async readFile(
     path: string,
     encoding: string = "utf-8",
@@ -520,7 +498,6 @@ export class HttpClient {
     }
   }
 
-
   async deleteFile(
     path: string,
     sessionId?: string
@@ -560,7 +537,6 @@ export class HttpClient {
     }
   }
 
-
   async renameFile(
     oldPath: string,
     newPath: string,
@@ -602,7 +578,6 @@ export class HttpClient {
     }
   }
 
-
   async moveFile(
     sourcePath: string,
     destinationPath: string,
@@ -644,7 +619,6 @@ export class HttpClient {
     }
   }
 
-
   async exposePort(port: number, name?: string): Promise<ExposePortResponse> {
     try {
       const response = await this.doFetch(`/api/expose-port`, {
@@ -670,7 +644,9 @@ export class HttpClient {
 
       const data: ExposePortResponse = await response.json();
       console.log(
-        `[HTTP Client] Port exposed: ${port}${name ? ` (${name})` : ""}, Success: ${data.success}`
+        `[HTTP Client] Port exposed: ${port}${
+          name ? ` (${name})` : ""
+        }, Success: ${data.success}`
       );
 
       return data;
@@ -732,9 +708,7 @@ export class HttpClient {
       }
 
       const data: GetExposedPortsResponse = await response.json();
-      console.log(
-        `[HTTP Client] Got ${data.count} exposed ports`
-      );
+      console.log(`[HTTP Client] Got ${data.count} exposed ports`);
 
       return data;
     } catch (error) {
@@ -871,9 +845,7 @@ export class HttpClient {
       }
 
       const data: ListProcessesResponse = await response.json();
-      console.log(
-        `[HTTP Client] Listed ${data.processes.length} processes`
-      );
+      console.log(`[HTTP Client] Listed ${data.processes.length} processes`);
 
       return data;
     } catch (error) {
@@ -902,7 +874,9 @@ export class HttpClient {
 
       const data: GetProcessResponse = await response.json();
       console.log(
-        `[HTTP Client] Got process ${processId}: ${data.process?.status || 'not found'}`
+        `[HTTP Client] Got process ${processId}: ${
+          data.process?.status || "not found"
+        }`
       );
 
       return data;
@@ -912,7 +886,9 @@ export class HttpClient {
     }
   }
 
-  async killProcess(processId: string): Promise<{ success: boolean; message: string }> {
+  async killProcess(
+    processId: string
+  ): Promise<{ success: boolean; message: string }> {
     try {
       const response = await this.doFetch(`/api/process/${processId}`, {
         headers: {
@@ -930,10 +906,11 @@ export class HttpClient {
         );
       }
 
-      const data = await response.json() as { success: boolean; message: string };
-      console.log(
-        `[HTTP Client] Killed process ${processId}`
-      );
+      const data = (await response.json()) as {
+        success: boolean;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed process ${processId}`);
 
       return data;
     } catch (error) {
@@ -942,7 +919,11 @@ export class HttpClient {
     }
   }
 
-  async killAllProcesses(): Promise<{ success: boolean; killedCount: number; message: string }> {
+  async killAllProcesses(): Promise<{
+    success: boolean;
+    killedCount: number;
+    message: string;
+  }> {
     try {
       const response = await this.doFetch("/api/process/kill-all", {
         headers: {
@@ -960,10 +941,12 @@ export class HttpClient {
         );
       }
 
-      const data = await response.json() as { success: boolean; killedCount: number; message: string };
-      console.log(
-        `[HTTP Client] Killed ${data.killedCount} processes`
-      );
+      const data = (await response.json()) as {
+        success: boolean;
+        killedCount: number;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed ${data.killedCount} processes`);
 
       return data;
     } catch (error) {
@@ -991,9 +974,7 @@ export class HttpClient {
       }
 
       const data: GetProcessLogsResponse = await response.json();
-      console.log(
-        `[HTTP Client] Got logs for process ${processId}`
-      );
+      console.log(`[HTTP Client] Got logs for process ${processId}`);
 
       return data;
     } catch (error) {
@@ -1002,11 +983,13 @@ export class HttpClient {
     }
   }
 
-  async streamProcessLogs(processId: string): Promise<ReadableStream<Uint8Array>> {
+  async streamProcessLogs(
+    processId: string
+  ): Promise<ReadableStream<Uint8Array>> {
     try {
       const response = await this.doFetch(`/api/process/${processId}/stream`, {
         headers: {
-          "Accept": "text/event-stream",
+          Accept: "text/event-stream",
           "Cache-Control": "no-cache",
         },
         method: "GET",

package/src/errors.ts

@@ -0,0 +1,218 @@
+/**
+ * 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 Jupyter functionality is requested but the service is still initializing.
+ *
+ * Note: With the current implementation, requests wait for Jupyter to be ready.
+ * This error is only thrown when:
+ * 1. The request times out waiting for Jupyter (default: 30 seconds)
+ * 2. Jupyter initialization actually fails
+ *
+ * Most requests will succeed after a delay, not throw this error.
+ */
+export class JupyterNotReadyError extends SandboxError {
+  public readonly code = "JUPYTER_NOT_READY";
+  public readonly retryAfter: number;
+  public readonly progress?: number;
+
+  constructor(
+    message?: string,
+    options?: { retryAfter?: number; progress?: number }
+  ) {
+    super(
+      message || "Jupyter 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 JupyterNotReadyError
+ */
+export function isJupyterNotReadyError(
+  error: unknown
+): error is JupyterNotReadyError {
+  return error instanceof JupyterNotReadyError;
+}
+
+/**
+ * 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 JupyterNotReadyError ||
+    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")
+      );
+    }
+
+    // Jupyter initialization error
+    if (data.status === "initializing") {
+      return new JupyterNotReadyError(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/index.ts

@@ -1,20 +1,54 @@
 // Export types from client
 export type {
-  DeleteFileResponse, ExecuteResponse,
+  DeleteFileResponse,
+  ExecuteResponse,
   GitCheckoutResponse,
-  MkdirResponse, MoveFileResponse,
-  ReadFileResponse, RenameFileResponse, WriteFileResponse
+  MkdirResponse,
+  MoveFileResponse,
+  ReadFileResponse,
+  RenameFileResponse,
+  WriteFileResponse,
 } from "./client";
-
+// Export errors
+export {
+  CodeExecutionError,
+  ContainerNotReadyError,
+  ContextNotFoundError,
+  isJupyterNotReadyError,
+  isRetryableError,
+  isSandboxError,
+  JupyterNotReadyError,
+  parseErrorResponse,
+  SandboxError,
+  type SandboxErrorResponse,
+  SandboxNetworkError,
+  ServiceUnavailableError,
+} from "./errors";
+// Export code interpreter types
+export type {
+  ChartData,
+  CodeContext,
+  CreateContextOptions,
+  Execution,
+  ExecutionError,
+  OutputMessage,
+  Result,
+  RunCodeOptions,
+} from "./interpreter-types";
+// Export the implementations
+export { ResultImpl } from "./interpreter-types";
 // Re-export request handler utilities
 export {
-  proxyToSandbox, type RouteInfo, type SandboxEnv
-} from './request-handler';
-
+  proxyToSandbox,
+  type RouteInfo,
+  type SandboxEnv,
+} from "./request-handler";
 export { getSandbox, Sandbox } from "./sandbox";
-
 // Export SSE parser for converting ReadableStream to AsyncIterable
-export { asyncIterableToSSEStream, parseSSEStream, responseToAsyncIterable } from "./sse-parser";
-
+export {
+  asyncIterableToSSEStream,
+  parseSSEStream,
+  responseToAsyncIterable,
+} from "./sse-parser";
 // Export event types for streaming
 export type { ExecEvent, LogEvent } from "./types";