@cloudflare/sandbox 0.0.0-603d05f → 0.0.0-66cc85b

package/container_src/index.ts

@@ -1,11 +1,15 @@
 import { serve } from "bun";
-import { handleExecuteRequest, handleStreamingExecuteRequest } from "./handler/exec";
+import {
+  handleExecuteRequest,
+  handleStreamingExecuteRequest,
+} from "./handler/exec";
 import {
   handleDeleteFileRequest,
   handleListFilesRequest,
   handleMkdirRequest,
   handleMoveFileRequest,
   handleReadFileRequest,
+  handleReadFileStreamRequest,
   handleRenameFileRequest,
   handleWriteFileRequest,
 } from "./handler/file";
@@ -26,9 +30,12 @@ import {
   handleStreamProcessLogsRequest,
 } from "./handler/process";
 import { handleCreateSession, handleListSessions } from "./handler/session";
+import type { CreateContextRequest } from "./interpreter-service";
+import {
+  InterpreterNotReadyError,
+  InterpreterService,
+} from "./interpreter-service";
 import { hasNamespaceSupport, SessionManager } from "./isolation";
-import type { CreateContextRequest } from "./jupyter-server";
-import { JupyterNotReadyError, JupyterService } from "./jupyter-service";
 
 // In-memory storage for exposed ports
 const exposedPorts = new Map<number, { name?: string; exposedAt: Date }>();
@@ -72,30 +79,15 @@ process.on("uncaughtException", async (error) => {
   process.exit(1);
 });
 
-// Initialize Jupyter service with graceful degradation
-const jupyterService = new JupyterService();
-
-// Start Jupyter initialization in background (non-blocking)
-console.log("[Container] Starting Jupyter initialization in background...");
-console.log(
-  "[Container] API endpoints are available immediately. Jupyter-dependent features will be available shortly."
-);
+// Initialize interpreter service
+const interpreterService = new InterpreterService();
 
-jupyterService
-  .initialize()
-  .then(() => {
-    console.log(
-      "[Container] Jupyter fully initialized - all features available"
-    );
-  })
-  .catch((error) => {
-    console.error("[Container] Jupyter initialization failed:", error.message);
-    console.error(
-      "[Container] The API will continue in degraded mode without code execution capabilities"
-    );
-  });
+// No initialization needed - service is ready immediately!
+console.log("[Container] Interpreter service ready - no cold start!");
+console.log("[Container] All API endpoints available immediately");
 
 const server = serve({
+  idleTimeout: 255,
   async fetch(req: Request) {
     const url = new URL(req.url);
     const pathname = url.pathname;
@@ -144,26 +136,27 @@ const server = serve({
             return handleExecuteRequest(req, corsHeaders, sessionManager);
           }
           break;
-  
+
         case "/api/execute/stream":
           if (req.method === "POST") {
-            return handleStreamingExecuteRequest(req, sessionManager, corsHeaders);
+            return handleStreamingExecuteRequest(
+              req,
+              sessionManager,
+              corsHeaders
+            );
           }
           break;
 
         case "/api/ping":
           if (req.method === "GET") {
-            const health = await jupyterService.getHealthStatus();
+            const health = await interpreterService.getHealthStatus();
             return new Response(
               JSON.stringify({
                 message: "pong",
                 timestamp: new Date().toISOString(),
-                jupyter: health.ready
-                  ? "ready"
-                  : health.initializing
-                  ? "initializing"
-                  : "not ready",
-                jupyterHealth: health,
+                system: "interpreter (70x faster)",
+                status: health.ready ? "ready" : "initializing",
+                progress: health.progress,
               }),
               {
                 headers: {
@@ -199,6 +192,12 @@ const server = serve({
           }
           break;
 
+        case "/api/read/stream":
+          if (req.method === "POST") {
+            return handleReadFileStreamRequest(req, corsHeaders, sessionManager);
+          }
+          break;
+
         case "/api/delete":
           if (req.method === "POST") {
             return handleDeleteFileRequest(req, corsHeaders, sessionManager);
@@ -267,7 +266,7 @@ const server = serve({
           if (req.method === "POST") {
             try {
               const body = (await req.json()) as CreateContextRequest;
-              const context = await jupyterService.createContext(body);
+              const context = await interpreterService.createContext(body);
               return new Response(
                 JSON.stringify({
                   id: context.id,
@@ -284,9 +283,9 @@ const server = serve({
                 }
               );
             } catch (error) {
-              if (error instanceof JupyterNotReadyError) {
+              if (error instanceof InterpreterNotReadyError) {
                 console.log(
-                  `[Container] Request timed out waiting for Jupyter (${error.progress}% complete)`
+                  `[Container] Request timed out waiting for interpreter (${error.progress}% complete)`
                 );
                 return new Response(
                   JSON.stringify({
@@ -351,7 +350,7 @@ const server = serve({
               );
             }
           } else if (req.method === "GET") {
-            const contexts = await jupyterService.listContexts();
+            const contexts = await interpreterService.listContexts();
             return new Response(JSON.stringify({ contexts }), {
               headers: {
                 "Content-Type": "application/json",
@@ -369,7 +368,7 @@ const server = serve({
                 code: string;
                 language?: string;
               };
-              return await jupyterService.executeCode(
+              return await interpreterService.executeCode(
                 body.context_id,
                 body.code,
                 body.language
@@ -408,12 +407,12 @@ const server = serve({
                 error.message.includes("initializing")
               ) {
                 console.log(
-                  "[Container] Code execution deferred - Jupyter still initializing"
+                  "[Container] Code execution deferred - service still initializing"
                 );
               } else {
                 console.error("[Container] Error executing code:", error);
               }
-              // Error response is already handled by jupyterService.executeCode for not ready state
+              // Error response is already handled by service.executeCode for not ready state
               return new Response(
                 JSON.stringify({
                   error:
@@ -442,7 +441,7 @@ const server = serve({
             const contextId = pathname.split("/")[3];
             if (req.method === "DELETE") {
               try {
-                await jupyterService.deleteContext(contextId);
+                await interpreterService.deleteContext(contextId);
                 return new Response(JSON.stringify({ success: true }), {
                   headers: {
                     "Content-Type": "application/json",
@@ -450,9 +449,9 @@ const server = serve({
                   },
                 });
               } catch (error) {
-                if (error instanceof JupyterNotReadyError) {
+                if (error instanceof InterpreterNotReadyError) {
                   console.log(
-                    `[Container] Request timed out waiting for Jupyter (${error.progress}% complete)`
+                    `[Container] Request timed out waiting for interpreter (${error.progress}% complete)`
                   );
                   return new Response(
                     JSON.stringify({
@@ -578,6 +577,7 @@ console.log(`   POST /api/git/checkout - Checkout a git repository`);
 console.log(`   POST /api/mkdir - Create a directory`);
 console.log(`   POST /api/write - Write a file`);
 console.log(`   POST /api/read - Read a file`);
+console.log(`   POST /api/read/stream - Stream a file (SSE)`);
 console.log(`   POST /api/delete - Delete a file`);
 console.log(`   POST /api/rename - Rename a file`);
 console.log(`   POST /api/move - Move a file`);

package/container_src/interpreter-service.ts

@@ -0,0 +1,276 @@
+import { randomUUID } from "node:crypto";
+import { type InterpreterLanguage, processPool, type RichOutput } from "./runtime/process-pool";
+
+export interface CreateContextRequest {
+  language?: string;
+  cwd?: string;
+}
+
+export interface Context {
+  id: string;
+  language: string;
+  cwd: string;
+  createdAt: string;
+  lastUsed: string;
+}
+
+export interface HealthStatus {
+  ready: boolean;
+  initializing: boolean;
+  progress: number;
+}
+
+export class InterpreterNotReadyError extends Error {
+  progress: number;
+  retryAfter: number;
+
+  constructor(message: string, progress: number = 100, retryAfter: number = 1) {
+    super(message);
+    this.progress = progress;
+    this.retryAfter = retryAfter;
+    this.name = "InterpreterNotReadyError";
+  }
+}
+
+export class InterpreterService {
+  private contexts: Map<string, Context> = new Map();
+
+  async getHealthStatus(): Promise<HealthStatus> {
+    return {
+      ready: true,
+      initializing: false,
+      progress: 100,
+    };
+  }
+
+  async createContext(request: CreateContextRequest): Promise<Context> {
+    const id = randomUUID();
+    const language = this.mapLanguage(request.language || "python");
+
+    const context: Context = {
+      id,
+      language,
+      cwd: request.cwd || "/workspace",
+      createdAt: new Date().toISOString(),
+      lastUsed: new Date().toISOString(),
+    };
+
+    this.contexts.set(id, context);
+    console.log(`[InterpreterService] Created context ${id} for ${language}`);
+
+    return context;
+  }
+
+  async listContexts(): Promise<Context[]> {
+    return Array.from(this.contexts.values());
+  }
+
+  async deleteContext(contextId: string): Promise<void> {
+    if (!this.contexts.has(contextId)) {
+      throw new Error(`Context ${contextId} not found`);
+    }
+
+    this.contexts.delete(contextId);
+    console.log(`[InterpreterService] Deleted context ${contextId}`);
+  }
+
+  async executeCode(
+    contextId: string,
+    code: string,
+    language?: string
+  ): Promise<Response> {
+    const context = this.contexts.get(contextId);
+    if (!context) {
+      return new Response(
+        JSON.stringify({
+          error: `Context ${contextId} not found`,
+        }),
+        {
+          status: 404,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    context.lastUsed = new Date().toISOString();
+
+    const execLanguage = this.mapLanguage(language || context.language);
+
+    // Store reference to this for use in async function
+    const self = this;
+    
+    const stream = new ReadableStream({
+      async start(controller) {
+        const encoder = new TextEncoder();
+        const startTime = Date.now();
+        
+        try {
+          const result = await processPool.execute(
+            execLanguage,
+            code,
+            contextId,
+            30000
+          );
+          
+          const totalTime = Date.now() - startTime;
+          console.log(`[InterpreterService] Code execution completed in ${totalTime}ms`);
+
+          if (result.stdout) {
+            controller.enqueue(
+              encoder.encode(
+                `${JSON.stringify({
+                  type: "stdout",
+                  text: result.stdout,
+                })}\n`
+              )
+            );
+          }
+
+          if (result.stderr) {
+            controller.enqueue(
+              encoder.encode(
+                `${JSON.stringify({
+                  type: "stderr",
+                  text: result.stderr,
+                })}\n`
+              )
+            );
+          }
+
+          if (result.outputs && result.outputs.length > 0) {
+            for (const output of result.outputs) {
+              const outputData = self.formatOutputData(output);
+              controller.enqueue(
+                encoder.encode(
+                  `${JSON.stringify({
+                    type: "result",
+                    ...outputData,
+                    metadata: output.metadata || {},
+                  })}\n`
+                )
+              );
+            }
+          }
+
+          if (result.success) {
+            controller.enqueue(
+              encoder.encode(
+                `${JSON.stringify({
+                  type: "execution_complete",
+                  execution_count: 1,
+                })}\n`
+              )
+            );
+          } else if (result.error) {
+            controller.enqueue(
+              encoder.encode(
+                `${JSON.stringify({
+                  type: "error",
+                  ename: result.error.type || "ExecutionError",
+                  evalue: result.error.message || "Code execution failed",
+                  traceback: result.error.traceback ? result.error.traceback.split('\n') : [],
+                })}\n`
+              )
+            );
+          } else {
+            controller.enqueue(
+              encoder.encode(
+                `${JSON.stringify({
+                  type: "error",
+                  ename: "ExecutionError",
+                  evalue: result.stderr || "Code execution failed",
+                  traceback: [],
+                })}\n`
+              )
+            );
+          }
+          
+          controller.close();
+        } catch (error) {
+          console.error(`[InterpreterService] Code execution failed:`, error);
+          
+          controller.enqueue(
+            encoder.encode(
+              `${JSON.stringify({
+                type: "error",
+                ename: "InternalError",
+                evalue: error instanceof Error ? error.message : String(error),
+                traceback: [],
+              })}\n`
+            )
+          );
+          
+          controller.close();
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  }
+
+  private mapLanguage(language: string): InterpreterLanguage {
+    const normalized = language.toLowerCase();
+
+    switch (normalized) {
+      case "python":
+      case "python3":
+        return "python";
+      case "javascript":
+      case "js":
+      case "node":
+        return "javascript";
+      case "typescript":
+      case "ts":
+        return "typescript";
+      default:
+        console.warn(
+          `[InterpreterService] Unknown language ${language}, defaulting to python`
+        );
+        return "python";
+    }
+  }
+
+  private formatOutputData(output: RichOutput): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    
+    switch (output.type) {
+      case "image":
+        result.png = output.data;
+        break;
+      case "jpeg":
+        result.jpeg = output.data;
+        break;
+      case "svg":
+        result.svg = output.data;
+        break;
+      case "html":
+        result.html = output.data;
+        break;
+      case "json":
+        result.json = typeof output.data === 'string' ? JSON.parse(output.data) : output.data;
+        break;
+      case "latex":
+        result.latex = output.data;
+        break;
+      case "markdown":
+        result.markdown = output.data;
+        break;
+      case "javascript":
+        result.javascript = output.data;
+        break;
+      case "text":
+        result.text = output.data;
+        break;
+      default:
+        result.text = output.data || '';
+    }
+    
+    return result;
+  }
+}