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

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
  * 
@@ -35,11 +35,11 @@ import type { ProcessRecord, ProcessStatus } from './types';
 // Configuration constants
 const CONFIG = {
   // Timeouts (in milliseconds)
-  COMMAND_TIMEOUT_MS: 30000,        // 30 seconds for command execution
   READY_TIMEOUT_MS: 5000,           // 5 seconds for control process to initialize
-  CLEANUP_INTERVAL_MS: 30000,       // Run cleanup every 30 seconds
-  TEMP_FILE_MAX_AGE_MS: 60000,      // Delete temp files older than 60 seconds
   SHUTDOWN_GRACE_PERIOD_MS: 500,    // Grace period for cleanup on shutdown
+  COMMAND_TIMEOUT_MS: parseInt(process.env.COMMAND_TIMEOUT_MS || '30000'),        // 30 seconds for command execution
+  CLEANUP_INTERVAL_MS: parseInt(process.env.CLEANUP_INTERVAL_MS || '30000'),       // Run cleanup every 30 seconds
+  TEMP_FILE_MAX_AGE_MS: parseInt(process.env.TEMP_FILE_MAX_AGE_MS || '60000'),      // Delete temp files older than 60 seconds
   
   // Default paths
   DEFAULT_CWD: '/workspace',
@@ -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
@@ -423,12 +430,11 @@ export class Session {
   
   // File Operations - Execute as shell commands to inherit session context
   async writeFileOperation(path: string, content: string, encoding: string = 'utf-8'): Promise<{ success: boolean; exitCode: number; path: string }> {
-    // Escape content for safe heredoc usage
-    const safeContent = content.replace(/'/g, "'\\''");
-    
     // Create parent directory if needed, then write file using heredoc
+    // Note: The quoted heredoc delimiter 'SANDBOX_EOF' prevents variable expansion
+    // and treats the content literally, so no escaping is required
     const command = `mkdir -p "$(dirname "${path}")" && cat > "${path}" << 'SANDBOX_EOF'
-${safeContent}
+${content}
 SANDBOX_EOF`;
     
     const result = await this.exec(command);
@@ -440,16 +446,180 @@ SANDBOX_EOF`;
     };
   }
 
-  async readFileOperation(path: string, encoding: string = 'utf-8'): Promise<{ success: boolean; exitCode: number; content: string; path: string }> {
-    const command = `cat "${path}"`;
-    const result = await this.exec(command);
-    
+  async readFileOperation(path: string, encoding: string = 'utf-8'): Promise<{
+    success: boolean;
+    exitCode: number;
+    content: string;
+    path: string;
+    encoding?: 'utf-8' | 'base64';
+    isBinary?: boolean;
+    mimeType?: string;
+    size?: number;
+  }> {
+    // Step 1: Check if file exists and get metadata
+    const statCommand = `stat -c '%s' "${path}" 2>/dev/null || echo "FILE_NOT_FOUND"`;
+    const statResult = await this.exec(statCommand);
+
+    if (statResult.stdout.trim() === 'FILE_NOT_FOUND') {
+      // File doesn't exist - return error
+      return {
+        success: false,
+        exitCode: 1,
+        content: '',
+        path
+      };
+    }
+
+    const fileSize = parseInt(statResult.stdout.trim(), 10);
+
+    // Step 2: Detect MIME type using file command
+    const mimeCommand = `file --mime-type -b "${path}"`;
+    const mimeResult = await this.exec(mimeCommand);
+    const mimeType = mimeResult.stdout.trim();
+
+    // Step 3: Determine if file is binary based on MIME type
+    // Text MIME types: text/*, application/json, application/xml, application/javascript, etc.
+    const isBinary = !mimeType.startsWith('text/') &&
+                     !mimeType.includes('json') &&
+                     !mimeType.includes('xml') &&
+                     !mimeType.includes('javascript') &&
+                     !mimeType.includes('x-empty');
+
+    // Step 4: Read file with appropriate encoding
+    let content: string;
+    let actualEncoding: 'utf-8' | 'base64';
+
+    if (isBinary) {
+      // Use base64 for binary files
+      const base64Command = `base64 -w 0 "${path}"`;
+      const base64Result = await this.exec(base64Command);
+      content = base64Result.stdout;
+      actualEncoding = 'base64';
+    } else {
+      // Use cat for text files
+      const catCommand = `cat "${path}"`;
+      const catResult = await this.exec(catCommand);
+      content = catResult.stdout;
+      actualEncoding = 'utf-8';
+    }
+
     return {
-      success: result.exitCode === 0,
-      exitCode: result.exitCode,
-      content: result.stdout,
-      path
+      success: true,
+      exitCode: 0,
+      content,
+      path,
+      encoding: actualEncoding,
+      isBinary,
+      mimeType,
+      size: fileSize
+    };
+  }
+
+  async readFileStreamOperation(path: string): Promise<ReadableStream<Uint8Array>> {
+    const encoder = new TextEncoder();
+
+    // Helper to send SSE event
+    const sseEvent = (event: any): Uint8Array => {
+      return encoder.encode(`data: ${JSON.stringify(event)}\n\n`);
     };
+
+    // Create streaming response
+    return new ReadableStream({
+      start: async (controller) => {
+        try {
+          // Step 1: Get file metadata (same logic as readFileOperation)
+          const statCommand = `stat -c '%s' "${path}" 2>/dev/null || echo "FILE_NOT_FOUND"`;
+          const statResult = await this.exec(statCommand);
+
+          if (statResult.stdout.trim() === 'FILE_NOT_FOUND') {
+            // File doesn't exist - send error event
+            controller.enqueue(sseEvent({
+              type: 'error',
+              error: `File not found: ${path}`
+            }));
+            controller.close();
+            return;
+          }
+
+          const fileSize = parseInt(statResult.stdout.trim(), 10);
+
+          // Step 2: Detect MIME type
+          const mimeCommand = `file --mime-type -b "${path}"`;
+          const mimeResult = await this.exec(mimeCommand);
+          const mimeType = mimeResult.stdout.trim();
+
+          // Step 3: Determine if binary
+          const isBinary = !mimeType.startsWith('text/') &&
+                           !mimeType.includes('json') &&
+                           !mimeType.includes('xml') &&
+                           !mimeType.includes('javascript') &&
+                           !mimeType.includes('x-empty');
+
+          const encoding: 'utf-8' | 'base64' = isBinary ? 'base64' : 'utf-8';
+
+          // Step 4: Send metadata event
+          controller.enqueue(sseEvent({
+            type: 'metadata',
+            mimeType,
+            size: fileSize,
+            isBinary,
+            encoding
+          }));
+
+          // Step 5: Stream file in chunks
+          // IMPORTANT: Chunk size MUST be divisible by 3 for base64 encoding!
+          // Base64 encodes 3 bytes at a time. If chunks aren't aligned,
+          // concatenating separately-encoded base64 strings corrupts the data.
+          const CHUNK_SIZE = 65535;
+          let bytesRead = 0;
+
+          while (bytesRead < fileSize) {
+            const remainingBytes = fileSize - bytesRead;
+            const chunkSize = Math.min(CHUNK_SIZE, remainingBytes);
+
+            // Use dd to read chunk at specific offset
+            // bs=1 means 1 byte block size, skip=offset, count=chunkSize
+            let chunkCommand: string;
+            if (isBinary) {
+              // For binary, read and encode as base64
+              chunkCommand = `dd if="${path}" bs=1 skip=${bytesRead} count=${chunkSize} 2>/dev/null | base64 -w 0`;
+            } else {
+              // For text, just read
+              chunkCommand = `dd if="${path}" bs=1 skip=${bytesRead} count=${chunkSize} 2>/dev/null`;
+            }
+
+            const chunkResult = await this.exec(chunkCommand);
+
+            // Send chunk event
+            controller.enqueue(sseEvent({
+              type: 'chunk',
+              data: chunkResult.stdout
+            }));
+
+            bytesRead += chunkSize;
+          }
+
+          // Step 6: Send complete event
+          controller.enqueue(sseEvent({
+            type: 'complete',
+            bytesRead
+          }));
+
+          controller.close();
+        } catch (error) {
+          // Send error event
+          controller.enqueue(sseEvent({
+            type: 'error',
+            error: error instanceof Error ? error.message : String(error)
+          }));
+          controller.close();
+        }
+      },
+
+      cancel() {
+        console.log(`[Session] File stream cancelled for: ${path}`);
+      }
+    });
   }
 
   async mkdirOperation(path: string, recursive: boolean = false): Promise<{ success: boolean; exitCode: number; path: string; recursive: boolean }> {
@@ -947,17 +1117,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;
@@ -973,15 +1151,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> {
@@ -1000,7 +1174,7 @@ export class SessionManager {
     return defaultSession.writeFileOperation(path, content, encoding);
   }
 
-  async readFile(path: string, encoding?: string): Promise<{ success: boolean; exitCode: number; content: string; path: string }> {
+  async readFile(path: string, encoding?: string): Promise<{ success: boolean; exitCode: number; content: string; path: string; encoding?: 'utf-8' | 'base64'; isBinary?: boolean; mimeType?: string; size?: number }> {
     const defaultSession = await this.getOrCreateDefaultSession();
     return defaultSession.readFileOperation(path, encoding);
   }
@@ -1036,4 +1210,4 @@ export class SessionManager {
     }
     this.sessions.clear();
   }
-}
+}

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