@cloudflare/sandbox 0.0.0-fb3c9c2 → 0.0.0-feafd32

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;
+  }
+}

package/container_src/isolation.ts

@@ -3,7 +3,7 @@
  * 
  * Implements PID namespace isolation to secure the sandbox environment.
  * Executed commands run in isolated namespaces, preventing them from:
- * - Seeing or killing control plane processes (Jupyter, Bun)
+ * - Seeing or killing control plane processes (Bun)
  * - Accessing platform secrets in /proc
  * - Hijacking control plane ports
  * 
@@ -121,13 +121,20 @@ export class Session {
     timeout: NodeJS.Timeout;
   }>();
   private processes = new Map<string, ProcessRecord>();  // Session-specific processes
-  
+
   constructor(private options: SessionOptions) {
     this.canIsolate = (options.isolation === true) && hasNamespaceSupport();
     if (options.isolation === true && !this.canIsolate) {
       console.log(`[Session] Isolation requested for '${options.id}' but not available`);
     }
   }
+
+  /**
+   * Check if the session is ready for command execution
+   */
+  isReady(): boolean {
+    return this.ready && this.control !== null && !this.control.killed;
+  }
   
   async initialize(): Promise<void> {
     // Use the proper TypeScript control process file
@@ -946,17 +953,25 @@ export class SessionManager {
         throw new Error(`cwd must be an absolute path starting with '/', got: ${options.cwd}`);
       }
     }
-    
-    // Clean up existing session with same name
+
+    // Check if session already exists
     const existing = this.sessions.get(options.id);
     if (existing) {
-      existing.destroy();
+      // If the existing session is healthy and ready, reuse it
+      if (existing.isReady()) {
+        console.log(`[SessionManager] Reusing existing session '${options.id}'`);
+        return existing;
+      }
+
+      // If the session exists but is not ready, clean it up and create a new one
+      console.log(`[SessionManager] Destroying unhealthy session '${options.id}' before recreating`);
+      await existing.destroy();
     }
-    
+
     // Create new session
     const session = new Session(options);
     await session.initialize();
-    
+
     this.sessions.set(options.id, session);
     console.log(`[SessionManager] Created session '${options.id}'`);
     return session;
@@ -972,15 +987,11 @@ export class SessionManager {
 
   // Helper to get or create default session - reduces duplication
   async getOrCreateDefaultSession(): Promise<Session> {
-    let defaultSession = this.sessions.get('default');
-    if (!defaultSession) {
-      defaultSession = await this.createSession({ 
-        id: 'default',
-        cwd: '/workspace', // Consistent default working directory
-        isolation: true 
-      });
-    }
-    return defaultSession;
+    return await this.createSession({
+      id: 'default',
+      cwd: '/workspace', // Consistent default working directory
+      isolation: true
+    });
   }
   
   async exec(command: string, options?: { cwd?: string }): Promise<ExecResult> {

package/container_src/mime-processor.ts

@@ -28,7 +28,7 @@ export interface ChartData {
   library?: 'matplotlib' | 'plotly' | 'altair' | 'seaborn' | 'unknown';
 }
 
-export function processJupyterMessage(msg: any): ExecutionResult | null {
+export function processMessage(msg: any): ExecutionResult | null {
     const msgType = msg.header?.msg_type || msg.msg_type;
     
     switch (msgType) {

package/container_src/package.json

@@ -7,12 +7,12 @@
     "start": "bun run index.ts"
   },
   "dependencies": {
-    "@jupyterlab/services": "^7.0.0",
-    "ws": "^8.16.0",
+    "esbuild": "^0.21.5",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@types/ws": "^8.5.10",
-    "@types/uuid": "^9.0.7"
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^9.0.7",
+    "typescript": "^5.3.0"
   }
 }

package/container_src/runtime/executors/javascript/node_executor.ts

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+import * as readline from 'node:readline';
+import * as util from 'node:util';
+import * as vm from 'node:vm';
+import type { RichOutput } from '../../process-pool';
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: false
+});
+
+const sandbox = {
+  console: console,
+  process: process,
+  require: require,
+  Buffer: Buffer,
+  setTimeout: setTimeout,
+  setInterval: setInterval,
+  clearTimeout: clearTimeout,
+  clearInterval: clearInterval,
+  setImmediate: setImmediate,
+  clearImmediate: clearImmediate,
+  global: global,
+  __dirname: __dirname,
+  __filename: __filename
+};
+
+const context = vm.createContext(sandbox);
+
+console.log(JSON.stringify({ status: "ready" }));
+
+rl.on('line', async (line: string) => {
+  try {
+    const request = JSON.parse(line);
+    const { code, executionId } = request;
+    
+    const originalStdoutWrite = process.stdout.write;
+    const originalStderrWrite = process.stderr.write;
+    
+    let stdout = '';
+    let stderr = '';
+    
+    (process.stdout.write as any) = (chunk: string | Buffer, encoding?: BufferEncoding, callback?: () => void) => {
+      stdout += chunk.toString();
+      if (callback) callback();
+      return true;
+    };
+    
+    (process.stderr.write as any) = (chunk: string | Buffer, encoding?: BufferEncoding, callback?: () => void) => {
+      stderr += chunk.toString();
+      if (callback) callback();
+      return true;
+    };
+    
+    let result: unknown;
+    let success = true;
+    
+    try {
+      result = vm.runInContext(code, context, {
+        filename: `<execution-${executionId}>`,
+        timeout: 30000
+      });
+      
+    } catch (error: unknown) {
+      const err = error as Error;
+      stderr += err.stack || err.toString();
+      success = false;
+    } finally {
+      process.stdout.write = originalStdoutWrite;
+      process.stderr.write = originalStderrWrite;
+    }
+    
+    const outputs: RichOutput[] = [];
+    
+    if (result !== undefined) {
+      if (typeof result === 'object' && result !== null) {
+        outputs.push({
+          type: 'json',
+          data: JSON.stringify(result, null, 2),
+          metadata: {}
+        });
+      } else {
+        outputs.push({
+          type: 'text',
+          data: util.inspect(result, { showHidden: false, depth: null, colors: false }),
+          metadata: {}
+        });
+      }
+    }
+    
+    const response = {
+      stdout,
+      stderr,
+      success,
+      executionId,
+      outputs
+    };
+    
+    console.log(JSON.stringify(response));
+    
+  } catch (error: unknown) {
+    const err = error as Error;
+    console.log(JSON.stringify({
+      stdout: '',
+      stderr: `Error processing request: ${err.message}`,
+      success: false,
+      executionId: 'unknown',
+      outputs: []
+    }));
+  }
+});
+
+process.on('SIGTERM', () => {
+  rl.close();
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  rl.close();
+  process.exit(0);
+});