@cloudflare/sandbox 0.4.12 → 0.4.14

package/src/clients/interpreter-client.ts

@@ -6,16 +6,20 @@ import {
   type ExecutionError,
   type OutputMessage,
   type Result,
-  ResultImpl,
+  ResultImpl
 } from '@repo/shared';
 import type { ErrorResponse } from '../errors';
-import { createErrorFromResponse, ErrorCode, InterpreterNotReadyError } from '../errors';
+import {
+  createErrorFromResponse,
+  ErrorCode,
+  InterpreterNotReadyError
+} from '../errors';
 import { BaseHttpClient } from './base-client.js';
 import type { HttpClientOptions } from './types.js';
 
 // Streaming execution data from the server
 interface StreamingExecutionData {
-  type: "result" | "stdout" | "stderr" | "error" | "execution_complete";
+  type: 'result' | 'stdout' | 'stderr' | 'error' | 'execution_complete';
   text?: string;
   html?: string;
   png?: string; // base64
@@ -27,13 +31,13 @@ interface StreamingExecutionData {
   json?: unknown;
   chart?: {
     type:
-      | "line"
-      | "bar"
-      | "scatter"
-      | "pie"
-      | "histogram"
-      | "heatmap"
-      | "unknown";
+      | 'line'
+      | 'bar'
+      | 'scatter'
+      | 'pie'
+      | 'histogram'
+      | 'heatmap'
+      | 'unknown';
     data: unknown;
     options?: unknown;
   };
@@ -62,14 +66,14 @@ export class InterpreterClient extends BaseHttpClient {
     options: CreateContextOptions = {}
   ): Promise<CodeContext> {
     return this.executeWithRetry(async () => {
-      const response = await this.doFetch("/api/contexts", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
+      const response = await this.doFetch('/api/contexts', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          language: options.language || "python",
-          cwd: options.cwd || "/workspace",
-          env_vars: options.envVars,
-        }),
+          language: options.language || 'python',
+          cwd: options.cwd || '/workspace',
+          env_vars: options.envVars
+        })
       });
 
       if (!response.ok) {
@@ -87,7 +91,7 @@ export class InterpreterClient extends BaseHttpClient {
         language: data.language,
         cwd: data.cwd || '/workspace',
         createdAt: new Date(data.timestamp),
-        lastUsed: new Date(data.timestamp),
+        lastUsed: new Date(data.timestamp)
       };
     });
   }
@@ -100,18 +104,18 @@ export class InterpreterClient extends BaseHttpClient {
     timeoutMs?: number
   ): Promise<void> {
     return this.executeWithRetry(async () => {
-      const response = await this.doFetch("/api/execute/code", {
-        method: "POST",
+      const response = await this.doFetch('/api/execute/code', {
+        method: 'POST',
         headers: {
-          "Content-Type": "application/json",
-          Accept: "text/event-stream",
+          'Content-Type': 'application/json',
+          Accept: 'text/event-stream'
         },
         body: JSON.stringify({
           context_id: contextId,
           code,
           language,
           ...(timeoutMs !== undefined && { timeout_ms: timeoutMs })
-        }),
+        })
       });
 
       if (!response.ok) {
@@ -120,7 +124,7 @@ export class InterpreterClient extends BaseHttpClient {
       }
 
       if (!response.body) {
-        throw new Error("No response body for streaming execution");
+        throw new Error('No response body for streaming execution');
       }
 
       // Process streaming response
@@ -132,9 +136,9 @@ export class InterpreterClient extends BaseHttpClient {
 
   async listCodeContexts(): Promise<CodeContext[]> {
     return this.executeWithRetry(async () => {
-      const response = await this.doFetch("/api/contexts", {
-        method: "GET",
-        headers: { "Content-Type": "application/json" },
+      const response = await this.doFetch('/api/contexts', {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json' }
       });
 
       if (!response.ok) {
@@ -152,7 +156,7 @@ export class InterpreterClient extends BaseHttpClient {
         language: ctx.language,
         cwd: ctx.cwd || '/workspace',
         createdAt: new Date(data.timestamp),
-        lastUsed: new Date(data.timestamp),
+        lastUsed: new Date(data.timestamp)
       }));
     });
   }
@@ -160,8 +164,8 @@ export class InterpreterClient extends BaseHttpClient {
   async deleteCodeContext(contextId: string): Promise<void> {
     return this.executeWithRetry(async () => {
       const response = await this.doFetch(`/api/contexts/${contextId}`, {
-        method: "DELETE",
-        headers: { "Content-Type": "application/json" },
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' }
       });
 
       if (!response.ok) {
@@ -201,7 +205,7 @@ export class InterpreterClient extends BaseHttpClient {
       }
     }
 
-    throw lastError || new Error("Execution failed after retries");
+    throw lastError || new Error('Execution failed after retries');
   }
 
   private isRetryableError(error: unknown): boolean {
@@ -211,8 +215,8 @@ export class InterpreterClient extends BaseHttpClient {
 
     if (error instanceof Error) {
       return (
-        error.message.includes("not ready") ||
-        error.message.includes("initializing")
+        error.message.includes('not ready') ||
+        error.message.includes('initializing')
       );
     }
 
@@ -221,7 +225,7 @@ export class InterpreterClient extends BaseHttpClient {
 
   private async parseErrorResponse(response: Response): Promise<Error> {
     try {
-      const errorData = await response.json() as ErrorResponse;
+      const errorData = (await response.json()) as ErrorResponse;
       return createErrorFromResponse(errorData);
     } catch {
       // Fallback if response isn't JSON
@@ -240,7 +244,7 @@ export class InterpreterClient extends BaseHttpClient {
     stream: ReadableStream<Uint8Array>
   ): AsyncGenerator<string> {
     const reader = stream.getReader();
-    let buffer = "";
+    let buffer = '';
 
     try {
       while (true) {
@@ -250,11 +254,11 @@ export class InterpreterClient extends BaseHttpClient {
         }
         if (done) break;
 
-        let newlineIdx = buffer.indexOf("\n");
+        let newlineIdx = buffer.indexOf('\n');
         while (newlineIdx !== -1) {
           yield buffer.slice(0, newlineIdx);
           buffer = buffer.slice(newlineIdx + 1);
-          newlineIdx = buffer.indexOf("\n");
+          newlineIdx = buffer.indexOf('\n');
         }
       }
 
@@ -282,25 +286,25 @@ export class InterpreterClient extends BaseHttpClient {
       const data = JSON.parse(jsonData) as StreamingExecutionData;
 
       switch (data.type) {
-        case "stdout":
+        case 'stdout':
           if (callbacks.onStdout && data.text) {
             await callbacks.onStdout({
               text: data.text,
-              timestamp: data.timestamp || Date.now(),
+              timestamp: data.timestamp || Date.now()
             });
           }
           break;
 
-        case "stderr":
+        case 'stderr':
           if (callbacks.onStderr && data.text) {
             await callbacks.onStderr({
               text: data.text,
-              timestamp: data.timestamp || Date.now(),
+              timestamp: data.timestamp || Date.now()
             });
           }
           break;
 
-        case "result":
+        case 'result':
           if (callbacks.onResult) {
             // Create a ResultImpl instance from the raw data
             const result = new ResultImpl(data);
@@ -308,17 +312,17 @@ export class InterpreterClient extends BaseHttpClient {
           }
           break;
 
-        case "error":
+        case 'error':
           if (callbacks.onError) {
             await callbacks.onError({
-              name: data.ename || "Error",
-              message: data.evalue || "Unknown error",
-              traceback: data.traceback || [],
+              name: data.ename || 'Error',
+              message: data.evalue || 'Unknown error',
+              traceback: data.traceback || []
             });
           }
           break;
 
-        case "execution_complete":
+        case 'execution_complete':
           // Signal completion - callbacks can handle cleanup if needed
           break;
       }

package/src/clients/port-client.ts

@@ -1,17 +1,13 @@
 import type {
   PortCloseResult,
   PortExposeResult,
-  PortListResult,
+  PortListResult
 } from '@repo/shared';
 import { BaseHttpClient } from './base-client';
 import type { HttpClientOptions } from './types';
 
 // Re-export for convenience
-export type {
-  PortExposeResult,
-  PortCloseResult,
-  PortListResult,
-};
+export type { PortExposeResult, PortCloseResult, PortListResult };
 
 /**
  * Request interface for exposing ports
@@ -32,7 +28,6 @@ export interface UnexposePortRequest {
  * Client for port management and preview URL operations
  */
 export class PortClient extends BaseHttpClient {
-
   /**
    * Expose a port and get a preview URL
    * @param port - Port number to expose
@@ -69,9 +64,14 @@ export class PortClient extends BaseHttpClient {
    * @param port - Port number to unexpose
    * @param sessionId - The session ID for this operation
    */
-  async unexposePort(port: number, sessionId: string): Promise<PortCloseResult> {
+  async unexposePort(
+    port: number,
+    sessionId: string
+  ): Promise<PortCloseResult> {
     try {
-      const url = `/api/exposed-ports/${port}?session=${encodeURIComponent(sessionId)}`;
+      const url = `/api/exposed-ports/${port}?session=${encodeURIComponent(
+        sessionId
+      )}`;
       const response = await this.delete<PortCloseResult>(url);
 
       this.logSuccess('Port unexposed', `${port}`);
@@ -102,4 +102,4 @@ export class PortClient extends BaseHttpClient {
       throw error;
     }
   }
-}
+}

package/src/clients/process-client.ts

@@ -5,7 +5,7 @@ import type {
   ProcessListResult,
   ProcessLogsResult,
   ProcessStartResult,
-  StartProcessRequest,
+  StartProcessRequest
 } from '@repo/shared';
 import { BaseHttpClient } from './base-client';
 import type { HttpClientOptions } from './types';
@@ -18,15 +18,13 @@ export type {
   ProcessInfoResult,
   ProcessKillResult,
   ProcessLogsResult,
-  ProcessCleanupResult,
+  ProcessCleanupResult
 };
 
-
 /**
  * Client for background process management
  */
 export class ProcessClient extends BaseHttpClient {
-
   /**
    * Start a background process
    * @param command - Command to execute as a background process
@@ -42,7 +40,7 @@ export class ProcessClient extends BaseHttpClient {
       const data: StartProcessRequest = {
         command,
         sessionId,
-        processId: options?.processId,
+        processId: options?.processId
       };
 
       const response = await this.post<ProcessStartResult>(
@@ -70,7 +68,10 @@ export class ProcessClient extends BaseHttpClient {
       const url = `/api/process/list`;
       const response = await this.get<ProcessListResult>(url);
 
-      this.logSuccess('Processes listed', `${response.processes.length} processes`);
+      this.logSuccess(
+        'Processes listed',
+        `${response.processes.length} processes`
+      );
       return response;
     } catch (error) {
       this.logError('listProcesses', error);
@@ -157,11 +158,13 @@ export class ProcessClient extends BaseHttpClient {
    * Stream logs from a specific process (sandbox-scoped, not session-scoped)
    * @param processId - ID of the process to stream logs from
    */
-  async streamProcessLogs(processId: string): Promise<ReadableStream<Uint8Array>> {
+  async streamProcessLogs(
+    processId: string
+  ): Promise<ReadableStream<Uint8Array>> {
     try {
       const url = `/api/process/${processId}/stream`;
       const response = await this.doFetch(url, {
-        method: 'GET',
+        method: 'GET'
       });
 
       const stream = await this.handleStreamResponse(response);

package/src/clients/sandbox-client.ts

@@ -24,7 +24,7 @@ export class SandboxClient {
     // Ensure baseUrl is provided for all clients
     const clientOptions: HttpClientOptions = {
       baseUrl: 'http://localhost:3000',
-      ...options,
+      ...options
     };
 
     // Initialize all domain clients with shared options
@@ -36,6 +36,4 @@ export class SandboxClient {
     this.interpreter = new InterpreterClient(clientOptions);
     this.utils = new UtilityClient(clientOptions);
   }
-
-
-}
+}

package/src/clients/types.ts

@@ -4,7 +4,11 @@ import type { Logger } from '@repo/shared';
  * Minimal interface for container fetch functionality
  */
 export interface ContainerStub {
-  containerFetch(url: string, options: RequestInit, port?: number): Promise<Response>;
+  containerFetch(
+    url: string,
+    options: RequestInit,
+    port?: number
+  ): Promise<Response>;
 }
 
 /**
@@ -81,4 +85,4 @@ export type ResponseHandler<T> = (response: Response) => Promise<T>;
  */
 export interface SessionRequest {
   sessionId?: string;
-}
+}

package/src/clients/utility-client.ts

@@ -45,14 +45,13 @@ export interface CreateSessionResponse extends BaseApiResponse {
  * Client for health checks and utility operations
  */
 export class UtilityClient extends BaseHttpClient {
-
   /**
    * Ping the sandbox to check if it's responsive
    */
   async ping(): Promise<string> {
     try {
       const response = await this.get<PingResponse>('/api/ping');
-      
+
       this.logSuccess('Ping successful', response.message);
       return response.message;
     } catch (error) {
@@ -67,7 +66,7 @@ export class UtilityClient extends BaseHttpClient {
   async getCommands(): Promise<string[]> {
     try {
       const response = await this.get<CommandsResponse>('/api/commands');
-      
+
       this.logSuccess(
         'Commands retrieved',
         `${response.count} commands available`
@@ -84,7 +83,9 @@ export class UtilityClient extends BaseHttpClient {
    * Create a new execution session
    * @param options - Session configuration (id, env, cwd)
    */
-  async createSession(options: CreateSessionRequest): Promise<CreateSessionResponse> {
+  async createSession(
+    options: CreateSessionRequest
+  ): Promise<CreateSessionResponse> {
     try {
       const response = await this.post<CreateSessionResponse>(
         '/api/session/create',
@@ -112,8 +113,11 @@ export class UtilityClient extends BaseHttpClient {
     } catch (error) {
       // If version endpoint doesn't exist (old container), return 'unknown'
       // This allows for backward compatibility
-      this.logger.debug('Failed to get container version (may be old container)', { error });
+      this.logger.debug(
+        'Failed to get container version (may be old container)',
+        { error }
+      );
       return 'unknown';
     }
   }
-}
+}

package/src/errors/adapter.ts

@@ -5,11 +5,12 @@
  * No validation overhead since we control both sides
  */
 
-import type { 
+import type {
   CodeExecutionContext,
   CommandErrorContext,
   CommandNotFoundContext,
-  ContextNotFoundContext,ErrorResponse, 
+  ContextNotFoundContext,
+  ErrorResponse,
   FileExistsContext,
   FileNotFoundContext,
   FileSystemContext,
@@ -25,7 +26,8 @@ import type {
   PortNotExposedContext,
   ProcessErrorContext,
   ProcessNotFoundContext,
-  ValidationFailedContext,} from '@repo/shared/errors';
+  ValidationFailedContext
+} from '@repo/shared/errors';
 import { ErrorCode } from '@repo/shared/errors';
 
 import {
@@ -56,7 +58,7 @@ import {
   ProcessNotFoundError,
   SandboxError,
   ServiceNotRespondingError,
-  ValidationFailedError,
+  ValidationFailedError
 } from './classes';
 
 /**
@@ -68,13 +70,19 @@ export function createErrorFromResponse(errorResponse: ErrorResponse): Error {
   switch (errorResponse.code) {
     // File System Errors
     case ErrorCode.FILE_NOT_FOUND:
-      return new FileNotFoundError(errorResponse as unknown as ErrorResponse<FileNotFoundContext>);
+      return new FileNotFoundError(
+        errorResponse as unknown as ErrorResponse<FileNotFoundContext>
+      );
 
     case ErrorCode.FILE_EXISTS:
-      return new FileExistsError(errorResponse as unknown as ErrorResponse<FileExistsContext>);
+      return new FileExistsError(
+        errorResponse as unknown as ErrorResponse<FileExistsContext>
+      );
 
     case ErrorCode.PERMISSION_DENIED:
-      return new PermissionDeniedError(errorResponse as unknown as ErrorResponse<FileSystemContext>);
+      return new PermissionDeniedError(
+        errorResponse as unknown as ErrorResponse<FileSystemContext>
+      );
 
     case ErrorCode.IS_DIRECTORY:
     case ErrorCode.NOT_DIRECTORY:
@@ -85,93 +93,143 @@ export function createErrorFromResponse(errorResponse: ErrorResponse): Error {
     case ErrorCode.NAME_TOO_LONG:
     case ErrorCode.TOO_MANY_LINKS:
     case ErrorCode.FILESYSTEM_ERROR:
-      return new FileSystemError(errorResponse as unknown as ErrorResponse<FileSystemContext>);
+      return new FileSystemError(
+        errorResponse as unknown as ErrorResponse<FileSystemContext>
+      );
 
     // Command Errors
     case ErrorCode.COMMAND_NOT_FOUND:
-      return new CommandNotFoundError(errorResponse as unknown as ErrorResponse<CommandNotFoundContext>);
+      return new CommandNotFoundError(
+        errorResponse as unknown as ErrorResponse<CommandNotFoundContext>
+      );
 
     case ErrorCode.COMMAND_PERMISSION_DENIED:
     case ErrorCode.COMMAND_EXECUTION_ERROR:
     case ErrorCode.INVALID_COMMAND:
     case ErrorCode.STREAM_START_ERROR:
-      return new CommandError(errorResponse as unknown as ErrorResponse<CommandErrorContext>);
+      return new CommandError(
+        errorResponse as unknown as ErrorResponse<CommandErrorContext>
+      );
 
     // Process Errors
     case ErrorCode.PROCESS_NOT_FOUND:
-      return new ProcessNotFoundError(errorResponse as unknown as ErrorResponse<ProcessNotFoundContext>);
+      return new ProcessNotFoundError(
+        errorResponse as unknown as ErrorResponse<ProcessNotFoundContext>
+      );
 
     case ErrorCode.PROCESS_PERMISSION_DENIED:
     case ErrorCode.PROCESS_ERROR:
-      return new ProcessError(errorResponse as unknown as ErrorResponse<ProcessErrorContext>);
+      return new ProcessError(
+        errorResponse as unknown as ErrorResponse<ProcessErrorContext>
+      );
 
     // Port Errors
     case ErrorCode.PORT_ALREADY_EXPOSED:
-      return new PortAlreadyExposedError(errorResponse as unknown as ErrorResponse<PortAlreadyExposedContext>);
+      return new PortAlreadyExposedError(
+        errorResponse as unknown as ErrorResponse<PortAlreadyExposedContext>
+      );
 
     case ErrorCode.PORT_NOT_EXPOSED:
-      return new PortNotExposedError(errorResponse as unknown as ErrorResponse<PortNotExposedContext>);
+      return new PortNotExposedError(
+        errorResponse as unknown as ErrorResponse<PortNotExposedContext>
+      );
 
     case ErrorCode.INVALID_PORT_NUMBER:
     case ErrorCode.INVALID_PORT:
-      return new InvalidPortError(errorResponse as unknown as ErrorResponse<InvalidPortContext>);
+      return new InvalidPortError(
+        errorResponse as unknown as ErrorResponse<InvalidPortContext>
+      );
 
     case ErrorCode.SERVICE_NOT_RESPONDING:
-      return new ServiceNotRespondingError(errorResponse as unknown as ErrorResponse<PortErrorContext>);
+      return new ServiceNotRespondingError(
+        errorResponse as unknown as ErrorResponse<PortErrorContext>
+      );
 
     case ErrorCode.PORT_IN_USE:
-      return new PortInUseError(errorResponse as unknown as ErrorResponse<PortErrorContext>);
+      return new PortInUseError(
+        errorResponse as unknown as ErrorResponse<PortErrorContext>
+      );
 
     case ErrorCode.PORT_OPERATION_ERROR:
-      return new PortError(errorResponse as unknown as ErrorResponse<PortErrorContext>);
+      return new PortError(
+        errorResponse as unknown as ErrorResponse<PortErrorContext>
+      );
 
     case ErrorCode.CUSTOM_DOMAIN_REQUIRED:
-      return new CustomDomainRequiredError(errorResponse as unknown as ErrorResponse<InternalErrorContext>);
+      return new CustomDomainRequiredError(
+        errorResponse as unknown as ErrorResponse<InternalErrorContext>
+      );
 
     // Git Errors
     case ErrorCode.GIT_REPOSITORY_NOT_FOUND:
-      return new GitRepositoryNotFoundError(errorResponse as unknown as ErrorResponse<GitRepositoryNotFoundContext>);
+      return new GitRepositoryNotFoundError(
+        errorResponse as unknown as ErrorResponse<GitRepositoryNotFoundContext>
+      );
 
     case ErrorCode.GIT_AUTH_FAILED:
-      return new GitAuthenticationError(errorResponse as unknown as ErrorResponse<GitAuthFailedContext>);
+      return new GitAuthenticationError(
+        errorResponse as unknown as ErrorResponse<GitAuthFailedContext>
+      );
 
     case ErrorCode.GIT_BRANCH_NOT_FOUND:
-      return new GitBranchNotFoundError(errorResponse as unknown as ErrorResponse<GitBranchNotFoundContext>);
+      return new GitBranchNotFoundError(
+        errorResponse as unknown as ErrorResponse<GitBranchNotFoundContext>
+      );
 
     case ErrorCode.GIT_NETWORK_ERROR:
-      return new GitNetworkError(errorResponse as unknown as ErrorResponse<GitErrorContext>);
+      return new GitNetworkError(
+        errorResponse as unknown as ErrorResponse<GitErrorContext>
+      );
 
     case ErrorCode.GIT_CLONE_FAILED:
-      return new GitCloneError(errorResponse as unknown as ErrorResponse<GitErrorContext>);
+      return new GitCloneError(
+        errorResponse as unknown as ErrorResponse<GitErrorContext>
+      );
 
     case ErrorCode.GIT_CHECKOUT_FAILED:
-      return new GitCheckoutError(errorResponse as unknown as ErrorResponse<GitErrorContext>);
+      return new GitCheckoutError(
+        errorResponse as unknown as ErrorResponse<GitErrorContext>
+      );
 
     case ErrorCode.INVALID_GIT_URL:
-      return new InvalidGitUrlError(errorResponse as unknown as ErrorResponse<ValidationFailedContext>);
+      return new InvalidGitUrlError(
+        errorResponse as unknown as ErrorResponse<ValidationFailedContext>
+      );
 
     case ErrorCode.GIT_OPERATION_FAILED:
-      return new GitError(errorResponse as unknown as ErrorResponse<GitErrorContext>);
+      return new GitError(
+        errorResponse as unknown as ErrorResponse<GitErrorContext>
+      );
 
     // Code Interpreter Errors
     case ErrorCode.INTERPRETER_NOT_READY:
-      return new InterpreterNotReadyError(errorResponse as unknown as ErrorResponse<InterpreterNotReadyContext>);
+      return new InterpreterNotReadyError(
+        errorResponse as unknown as ErrorResponse<InterpreterNotReadyContext>
+      );
 
     case ErrorCode.CONTEXT_NOT_FOUND:
-      return new ContextNotFoundError(errorResponse as unknown as ErrorResponse<ContextNotFoundContext>);
+      return new ContextNotFoundError(
+        errorResponse as unknown as ErrorResponse<ContextNotFoundContext>
+      );
 
     case ErrorCode.CODE_EXECUTION_ERROR:
-      return new CodeExecutionError(errorResponse as unknown as ErrorResponse<CodeExecutionContext>);
+      return new CodeExecutionError(
+        errorResponse as unknown as ErrorResponse<CodeExecutionContext>
+      );
 
     // Validation Errors
     case ErrorCode.VALIDATION_FAILED:
-      return new ValidationFailedError(errorResponse as unknown as ErrorResponse<ValidationFailedContext>);
+      return new ValidationFailedError(
+        errorResponse as unknown as ErrorResponse<ValidationFailedContext>
+      );
 
     // Generic Errors
     case ErrorCode.INVALID_JSON_RESPONSE:
     case ErrorCode.UNKNOWN_ERROR:
     case ErrorCode.INTERNAL_ERROR:
-      return new SandboxError(errorResponse as unknown as ErrorResponse<InternalErrorContext>);
+      return new SandboxError(
+        errorResponse as unknown as ErrorResponse<InternalErrorContext>
+      );
 
     default:
       // Fallback for unknown error codes