@cloudflare/sandbox 0.3.1 → 0.3.3

package/container_src/runtime/process-pool.ts

@@ -0,0 +1,464 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+
+export type InterpreterLanguage = "python" | "javascript" | "typescript";
+
+export interface InterpreterProcess {
+  id: string;
+  language: InterpreterLanguage;
+  process: ChildProcess;
+  sessionId?: string;
+  lastUsed: Date;
+  isAvailable: boolean;
+}
+
+export interface ExecutionResult {
+  stdout: string;
+  stderr: string;
+  success: boolean;
+  executionId: string;
+  outputs?: RichOutput[];
+  error?: {
+    type: string;
+    message: string;
+    traceback?: string;
+  };
+}
+
+export interface RichOutput {
+  type: "text" | "image" | "jpeg" | "svg" | "html" | "json" | "latex" | "markdown" | "javascript" | "error";
+  data: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface PoolConfig {
+  maxProcesses: number;
+  idleTimeout: number; // milliseconds
+  minSize: number;
+  preWarmScript?: string;
+}
+
+export interface ExecutorPoolConfig extends PoolConfig {
+  executor: InterpreterLanguage;
+}
+
+const DEFAULT_EXECUTOR_CONFIGS: Record<InterpreterLanguage, ExecutorPoolConfig> = {
+  python: {
+    executor: "python",
+    minSize: 3,
+    maxProcesses: 15,
+    idleTimeout: 5 * 60 * 1000, // 5 minutes
+    preWarmScript: `
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+import json
+print(json.dumps({"status": "pre-warmed"}))
+`
+  },
+  javascript: {
+    executor: "javascript",
+    minSize: 3,
+    maxProcesses: 10,
+    idleTimeout: 5 * 60 * 1000,
+    preWarmScript: `
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const crypto = require('crypto');
+for(let i = 0; i < 1000; i++) {
+  JSON.stringify({x: i, data: Math.random()});
+}
+console.log(JSON.stringify({"status": "pre-warmed"}));
+`
+  },
+  typescript: {
+    executor: "typescript",
+    minSize: 3,  
+    maxProcesses: 10,
+    idleTimeout: 5 * 60 * 1000,
+    preWarmScript: `
+const { transformSync } = require('esbuild');
+const warmupCode = 'interface Test { x: number; } const test: Test = { x: 42 }; test.x';
+transformSync(warmupCode, { loader: 'ts', target: 'es2020', format: 'cjs' });
+console.log(JSON.stringify({"status": "pre-warmed"}));
+`
+  }
+};
+
+export class ProcessPoolManager {
+  private pools: Map<InterpreterLanguage, InterpreterProcess[]> = new Map();
+  private poolConfigs: Map<InterpreterLanguage, ExecutorPoolConfig> = new Map();
+  private cleanupInterval?: NodeJS.Timeout;
+
+  constructor(customConfigs: Partial<Record<InterpreterLanguage, Partial<ExecutorPoolConfig>>> = {}) {
+    const executorEntries = Object.entries(DEFAULT_EXECUTOR_CONFIGS) as [InterpreterLanguage, ExecutorPoolConfig][];
+    
+    for (const [executor, defaultConfig] of executorEntries) {
+      const userConfig = customConfigs[executor] || {};
+      const envMinSize = process.env[`${executor.toUpperCase()}_POOL_MIN_SIZE`];
+      const envMaxSize = process.env[`${executor.toUpperCase()}_POOL_MAX_SIZE`];
+      
+      const config: ExecutorPoolConfig = { 
+        ...defaultConfig, 
+        ...userConfig,
+        // Environment variables override user config override defaults
+        minSize: envMinSize ? parseInt(envMinSize) : (userConfig.minSize || defaultConfig.minSize),
+        maxProcesses: envMaxSize ? parseInt(envMaxSize) : (userConfig.maxProcesses || defaultConfig.maxProcesses)
+      };
+      
+      this.poolConfigs.set(executor, config);
+      this.pools.set(executor, []);
+    }
+
+    const pythonConfig = this.poolConfigs.get("python");
+    if (pythonConfig) {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanupIdleProcesses();
+      }, pythonConfig.idleTimeout / 2);
+    }
+
+    // Start pre-warming in background - don't block constructor
+    this.startPreWarming().catch((error) => {
+      console.error('[ProcessPool] Pre-warming failed:', error);
+    });
+  }
+
+  async execute(
+    language: InterpreterLanguage,
+    code: string,
+    sessionId?: string,
+    timeout = 30000
+  ): Promise<ExecutionResult> {
+    const totalStartTime = Date.now();
+    const process = await this.getProcess(language, sessionId);
+    const processAcquireTime = Date.now() - totalStartTime;
+    
+    const executionId = randomUUID();
+
+    try {
+      const execStartTime = Date.now();
+      const result = await this.executeCode(process, code, executionId, timeout);
+      const execTime = Date.now() - execStartTime;
+      const totalTime = Date.now() - totalStartTime;
+      
+      console.log(`[ProcessPool] Execution complete - Process acquire: ${processAcquireTime}ms, Code exec: ${execTime}ms, Total: ${totalTime}ms`);
+      return result;
+    } finally {
+      this.releaseProcess(process, sessionId);
+    }
+  }
+
+  private async getProcess(
+    language: InterpreterLanguage,
+    sessionId?: string
+  ): Promise<InterpreterProcess> {
+    const pool = this.pools.get(language)!;
+
+    if (sessionId) {
+      const existingProcess = pool.find(
+        (p) => p.sessionId === sessionId && p.isAvailable
+      );
+      if (existingProcess) {
+        existingProcess.isAvailable = false;
+        existingProcess.lastUsed = new Date();
+        return existingProcess;
+      }
+    }
+
+    const availableProcess = pool.find((p) => p.isAvailable && !p.sessionId);
+    if (availableProcess) {
+      availableProcess.isAvailable = false;
+      availableProcess.sessionId = sessionId;
+      availableProcess.lastUsed = new Date();
+      return availableProcess;
+    }
+
+    const config = this.poolConfigs.get(language)!;
+    if (pool.length < config.maxProcesses) {
+      const newProcess = await this.createProcess(language, sessionId);
+      pool.push(newProcess);
+      return newProcess;
+    }
+
+    return new Promise((resolve) => {
+      const checkForAvailable = () => {
+        const available = pool.find((p) => p.isAvailable);
+        if (available) {
+          available.isAvailable = false;
+          available.sessionId = sessionId;
+          available.lastUsed = new Date();
+          resolve(available);
+        } else {
+          setTimeout(checkForAvailable, 100);
+        }
+      };
+      checkForAvailable();
+    });
+  }
+
+  private async createProcess(
+    language: InterpreterLanguage,
+    sessionId?: string
+  ): Promise<InterpreterProcess> {
+    const startTime = Date.now();
+    const id = randomUUID();
+    let command: string;
+    let args: string[];
+
+    switch (language) {
+      case "python":
+        command = "python3";
+        args = ["-u", "/container-server/runtime/executors/python/ipython_executor.py"];
+        break;
+      case "javascript":
+        command = "node";
+        args = ["/container-server/runtime/executors/javascript/node_executor.js"];
+        break;
+      case "typescript":
+        command = "node";
+        args = ["/container-server/runtime/executors/typescript/ts_executor.js"];
+        break;
+    }
+
+    console.log(`[ProcessPool] Spawning ${language} process: ${command} ${args.join(' ')}`);
+    
+    const childProcess = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        PYTHONUNBUFFERED: "1",
+        NODE_NO_WARNINGS: "1",
+      },
+      cwd: "/workspace",
+    });
+
+    const interpreterProcess: InterpreterProcess = {
+      id,
+      language,
+      process: childProcess,
+      sessionId,
+      lastUsed: new Date(),
+      isAvailable: false,
+    };
+
+    return new Promise((resolve, reject) => {
+      let readyBuffer = "";
+      let errorBuffer = "";
+      
+      const timeout = setTimeout(() => {
+        childProcess.kill();
+        console.error(`[ProcessPool] ${language} executor timeout. stdout: "${readyBuffer}", stderr: "${errorBuffer}"`);
+        reject(new Error(`${language} executor failed to start`));
+      }, 5000);
+
+      const readyHandler = (data: Buffer) => {
+        readyBuffer += data.toString();
+        console.log(`[ProcessPool] ${language} stdout:`, data.toString());
+        
+        if (readyBuffer.includes('"ready"')) {
+          clearTimeout(timeout);
+          childProcess.stdout?.removeListener("data", readyHandler);
+          childProcess.stderr?.removeListener("data", errorHandler);
+          const readyTime = Date.now() - startTime;
+          console.log(`[ProcessPool] ${language} process ${id} ready in ${readyTime}ms`);
+          resolve(interpreterProcess);
+        }
+      };
+      
+      const errorHandler = (data: Buffer) => {
+        errorBuffer += data.toString();
+        console.error(`[ProcessPool] ${language} stderr:`, data.toString());
+      };
+
+      childProcess.stdout?.on("data", readyHandler);
+      childProcess.stderr?.on("data", errorHandler);
+      
+      childProcess.once("error", (err) => {
+        clearTimeout(timeout);
+        console.error(`[ProcessPool] ${language} spawn error:`, err);
+        reject(err);
+      });
+      
+      childProcess.once("exit", (code) => {
+        if (code !== 0) {
+          clearTimeout(timeout);
+          console.error(`[ProcessPool] ${language} exited with code ${code}`);
+          reject(new Error(`${language} executor exited with code ${code}`));
+        }
+      });
+    });
+  }
+
+  private async executeCode(
+    process: InterpreterProcess,
+    code: string,
+    executionId: string,
+    timeout: number
+  ): Promise<ExecutionResult> {
+    const request = JSON.stringify({ code, executionId });
+    
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error("Execution timeout"));
+      }, timeout);
+
+      let responseBuffer = "";
+      
+      const responseHandler = (data: Buffer) => {
+        responseBuffer += data.toString();
+        
+        try {
+          const response = JSON.parse(responseBuffer);
+          clearTimeout(timer);
+          process.process.stdout?.removeListener("data", responseHandler);
+          
+          resolve({
+            stdout: response.stdout || "",
+            stderr: response.stderr || "",
+            success: response.success !== false,
+            executionId,
+            outputs: response.outputs || [],
+            error: response.error || null,
+          });
+        } catch (e) {
+        }
+      };
+      
+      process.process.stdout?.on("data", responseHandler);
+      process.process.stdin?.write(`${request}\n`);
+    });
+  }
+
+  private releaseProcess(
+    process: InterpreterProcess,
+    sessionId?: string
+  ): void {
+    if (!sessionId) {
+      process.sessionId = undefined;
+      process.isAvailable = true;
+    } else {
+      process.isAvailable = true;
+    }
+  }
+
+  private async startPreWarming(): Promise<void> {
+    console.log('[ProcessPool] Starting unified pre-warming for all executors...');
+    const startTime = Date.now();
+    
+    const warmupPromises = Array.from(this.poolConfigs.entries()).map(
+      async ([executor, config]) => {
+        if (config.minSize > 0) {
+          await this.preWarmExecutor(executor, config);
+        }
+      }
+    );
+
+    try {
+      await Promise.all(warmupPromises);
+      const totalTime = Date.now() - startTime;
+      console.log(`[ProcessPool] Pre-warming complete for all executors in ${totalTime}ms`);
+    } catch (error) {
+      console.error('[ProcessPool] Pre-warming failed:', error);
+    }
+  }
+
+  private async preWarmExecutor(executor: InterpreterLanguage, config: ExecutorPoolConfig): Promise<void> {
+    const startTime = Date.now();
+    console.log(`[ProcessPool] Pre-warming ${config.minSize} ${executor} processes...`);
+    
+    const pool = this.pools.get(executor);
+    if (!pool) {
+      console.error(`[ProcessPool] No pool found for executor: ${executor}`);
+      return;
+    }
+    
+    for (let i = 0; i < config.minSize; i++) {
+      try {
+        const sessionId = `pre-warm-${executor}-${i}-${Date.now()}`;
+        const process = await this.createProcess(executor, sessionId);
+        
+        if (config.preWarmScript) {
+          await this.executePreWarmScript(process, config.preWarmScript, executor);
+        }
+        
+        process.isAvailable = true;
+        process.sessionId = undefined;
+        pool.push(process);
+      } catch (error) {
+        console.error(`[ProcessPool] Failed to pre-warm ${executor} process ${i}:`, error);
+      }
+    }
+    
+    const warmupTime = Date.now() - startTime;
+    const actualCount = pool.filter(p => p.isAvailable).length;
+    console.log(`[ProcessPool] Pre-warmed ${actualCount}/${config.minSize} ${executor} processes in ${warmupTime}ms`);
+  }
+
+  private async executePreWarmScript(
+    process: InterpreterProcess, 
+    script: string, 
+    executor: InterpreterLanguage
+  ): Promise<void> {
+    try {
+      const executionId = `pre-warm-${Date.now()}`;
+      const result = await this.executeCode(process, script, executionId, 10000);
+      
+      if (result.success) {
+        console.log(`[ProcessPool] ${executor} pre-warm script executed successfully`);
+      } else {
+        console.warn(`[ProcessPool] ${executor} pre-warm script failed:`, result.stderr);
+      }
+    } catch (error) {
+      console.warn(`[ProcessPool] ${executor} pre-warm script error:`, error);
+    }
+  }
+
+  private cleanupIdleProcesses(): void {
+    const now = new Date();
+
+    const executors = Array.from(this.pools.keys());
+    for (const executor of executors) {
+      const pool = this.pools.get(executor);
+      const config = this.poolConfigs.get(executor);
+      
+      if (!pool || !config) {
+        continue;
+      }
+
+      for (let i = pool.length - 1; i >= 0; i--) {
+        const process = pool[i];
+        const idleTime = now.getTime() - process.lastUsed.getTime();
+
+        // Only clean up excess processes beyond minimum pool size
+        if (process.isAvailable && 
+            idleTime > config.idleTimeout && 
+            pool.filter(p => p.isAvailable).length > config.minSize) {
+          process.process.kill();
+          pool.splice(i, 1);
+          console.log(`[ProcessPool] Cleaned up idle ${executor} process (${pool.length} remaining)`);
+        }
+      }
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+
+    const executors = Array.from(this.pools.keys());
+    for (const executor of executors) {
+      const pool = this.pools.get(executor);
+      if (pool) {
+        for (const process of pool) {
+          process.process.kill();
+        }
+      }
+    }
+
+    this.pools.clear();
+  }
+}
+
+export const processPool = new ProcessPoolManager();

package/container_src/startup.sh

@@ -1,84 +1,11 @@
 #!/bin/bash
 
-# Function to check if Jupyter is ready
-check_jupyter_ready() {
-  # Check if API is responsive and kernelspecs are available
-  curl -s http://localhost:8888/api/kernelspecs > /dev/null 2>&1
-}
+echo "[Startup] Starting interpreter server..."
+echo "[Startup] Process pool system initialized"
 
-# Function to notify Bun server that Jupyter is ready
-notify_jupyter_ready() {
-  # Create a marker file that the Bun server can check
-  touch /tmp/jupyter-ready
-  echo "[Startup] Jupyter is ready, notified Bun server"
-}
+echo "[Startup] Environment configured:" 
+echo "  - Working directory: $(pwd)"
 
-# Start Jupyter server in background
-echo "[Startup] Starting Jupyter server..."
-jupyter server \
-  --config=/container-server/jupyter_config.py \
-  > /tmp/jupyter.log 2>&1 &
-
-JUPYTER_PID=$!
-
-# Start Bun server immediately (parallel startup)
+# Start Bun server - the only process we need now
 echo "[Startup] Starting Bun server..."
-bun index.ts &
-BUN_PID=$!
-
-# Monitor Jupyter readiness in background
-(
-  echo "[Startup] Monitoring Jupyter readiness in background..."
-  MAX_ATTEMPTS=60
-  ATTEMPT=0
-
-  # Track start time for reporting
-  START_TIME=$(date +%s.%N)
-
-  while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
-    if check_jupyter_ready; then
-      notify_jupyter_ready
-      END_TIME=$(date +%s.%N)
-      ELAPSED=$(awk "BEGIN {printf \"%.2f\", $END_TIME - $START_TIME}")
-      echo "[Startup] Jupyter server is ready after $ELAPSED seconds ($ATTEMPT attempts)"
-      break
-    fi
-
-    # Check if Jupyter process is still running
-    if ! kill -0 $JUPYTER_PID 2>/dev/null; then
-      echo "[Startup] WARNING: Jupyter process died. Check /tmp/jupyter.log for details"
-      cat /tmp/jupyter.log
-      # Don't exit - let Bun server continue running in degraded mode
-      break
-    fi
-
-    ATTEMPT=$((ATTEMPT + 1))
-
-    # Start with faster checks
-    if [ $ATTEMPT -eq 1 ]; then
-      DELAY=0.5  # Start at 0.5s
-    else
-      # Exponential backoff with 1.3x multiplier (less aggressive than 1.5x)
-      DELAY=$(awk "BEGIN {printf \"%.2f\", $DELAY * 1.3}")
-      # Cap at 2s max (instead of 5s)
-      if [ $(awk "BEGIN {print ($DELAY > 2)}") -eq 1 ]; then
-        DELAY=2
-      fi
-    fi
-
-    # Log with current delay for transparency
-    echo "[Startup] Jupyter not ready yet (attempt $ATTEMPT/$MAX_ATTEMPTS, next check in ${DELAY}s)"
-
-    sleep $DELAY
-  done
-
-  if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
-    echo "[Startup] WARNING: Jupyter failed to become ready within attempts"
-    echo "[Startup] Jupyter logs:"
-    cat /tmp/jupyter.log
-    # Don't exit - let Bun server continue in degraded mode
-  fi
-) &
-
-# Wait for Bun server (main process)
-wait $BUN_PID
+exec bun index.ts

package/dist/{chunk-LALY4SFU.js → chunk-FXYPFGOZ.js}

@@ -8,13 +8,13 @@ var SandboxError = class extends Error {
     }
   }
 };
-var JupyterNotReadyError = class extends SandboxError {
-  code = "JUPYTER_NOT_READY";
+var InterpreterNotReadyError = class extends SandboxError {
+  code = "INTERPRETER_NOT_READY";
   retryAfter;
   progress;
   constructor(message, options) {
     super(
-      message || "Jupyter is still initializing. Please retry in a few seconds."
+      message || "Interpreter is still initializing. Please retry in a few seconds."
     );
     this.retryAfter = options?.retryAfter || 5;
     this.progress = options?.progress;
@@ -62,14 +62,14 @@ var ServiceUnavailableError = class extends SandboxError {
     this.retryAfter = retryAfter;
   }
 };
-function isJupyterNotReadyError(error) {
-  return error instanceof JupyterNotReadyError;
+function isInterpreterNotReadyError(error) {
+  return error instanceof InterpreterNotReadyError;
 }
 function isSandboxError(error) {
   return error instanceof SandboxError;
 }
 function isRetryableError(error) {
-  if (error instanceof JupyterNotReadyError || error instanceof ContainerNotReadyError || error instanceof ServiceUnavailableError) {
+  if (error instanceof InterpreterNotReadyError || error instanceof ContainerNotReadyError || error instanceof ServiceUnavailableError) {
     return true;
   }
   if (error instanceof SandboxNetworkError) {
@@ -96,7 +96,7 @@ async function parseErrorResponse(response) {
       );
     }
     if (data.status === "initializing") {
-      return new JupyterNotReadyError(data.error, {
+      return new InterpreterNotReadyError(data.error, {
         retryAfter: parseInt(response.headers.get("Retry-After") || "5"),
         progress: data.progress
       });
@@ -115,15 +115,15 @@ async function parseErrorResponse(response) {
 
 export {
   SandboxError,
-  JupyterNotReadyError,
+  InterpreterNotReadyError,
   ContextNotFoundError,
   CodeExecutionError,
   ContainerNotReadyError,
   SandboxNetworkError,
   ServiceUnavailableError,
-  isJupyterNotReadyError,
+  isInterpreterNotReadyError,
   isSandboxError,
   isRetryableError,
   parseErrorResponse
 };
-//# sourceMappingURL=chunk-LALY4SFU.js.map
+//# sourceMappingURL=chunk-FXYPFGOZ.js.map

package/dist/chunk-FXYPFGOZ.js.map

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

package/dist/{chunk-LFLJGISB.js → chunk-H4PW2LGW.js}

@@ -5,11 +5,11 @@ import {
   validatePort
 } from "./chunk-6UAWTJ5S.js";
 import {
-  CodeInterpreter
-} from "./chunk-FKBV7CZS.js";
+  InterpreterClient
+} from "./chunk-Z6OZPC6U.js";
 import {
-  JupyterClient
-} from "./chunk-BEQUGUY4.js";
+  CodeInterpreter
+} from "./chunk-JTKON2SH.js";
 
 // src/sandbox.ts
 import { Container, getContainer } from "@cloudflare/containers";
@@ -130,7 +130,7 @@ var Sandbox = class extends Container {
   defaultSession = null;
   constructor(ctx, env) {
     super(ctx, env);
-    this.client = new JupyterClient({
+    this.client = new InterpreterClient({
       onCommandComplete: (success, exitCode, _stdout, _stderr, command) => {
         console.log(
           `[Container] Command completed: ${command}, Success: ${success}, Exit code: ${exitCode}`
@@ -664,4 +664,4 @@ export {
   proxyToSandbox,
   isLocalhostPattern
 };
-//# sourceMappingURL=chunk-LFLJGISB.js.map
+//# sourceMappingURL=chunk-H4PW2LGW.js.map