@cloudflare/sandbox 0.0.0-e1fa354 → 0.0.0-e489cbb

package/container_src/mime-processor.ts

@@ -1,255 +0,0 @@
-export interface ExecutionResult {
-  type: 'result' | 'stdout' | 'stderr' | 'error' | 'execution_complete';
-  text?: string;
-  html?: string;
-  png?: string;    // base64
-  jpeg?: string;   // base64
-  svg?: string;
-  latex?: string;
-  markdown?: string;
-  javascript?: string;
-  json?: any;
-  chart?: ChartData;
-  data?: any;
-  metadata?: any;
-  execution_count?: number;
-  ename?: string;
-  evalue?: string;
-  traceback?: string[];
-  timestamp: number;
-}
-
-export interface ChartData {
-  type: 'line' | 'bar' | 'scatter' | 'pie' | 'histogram' | 'heatmap' | 'unknown';
-  title?: string;
-  data: any;
-  layout?: any;
-  config?: any;
-  library?: 'matplotlib' | 'plotly' | 'altair' | 'seaborn' | 'unknown';
-}
-
-export function processJupyterMessage(msg: any): ExecutionResult | null {
-    const msgType = msg.header?.msg_type || msg.msg_type;
-    
-    switch (msgType) {
-      case 'execute_result':
-      case 'display_data':
-        return processDisplayData(msg.content.data, msg.content.metadata);
-        
-      case 'stream':
-        return {
-          type: msg.content.name === 'stdout' ? 'stdout' : 'stderr',
-          text: msg.content.text,
-          timestamp: Date.now()
-        };
-        
-      case 'error':
-        return {
-          type: 'error',
-          ename: msg.content.ename,
-          evalue: msg.content.evalue,
-          traceback: msg.content.traceback,
-          timestamp: Date.now()
-        };
-        
-      default:
-        return null;
-    }
-  }
-
-function processDisplayData(data: any, metadata?: any): ExecutionResult {
-    const result: ExecutionResult = {
-      type: 'result',
-      timestamp: Date.now(),
-      metadata
-    };
-    
-    // Process different MIME types in order of preference
-    
-    // Interactive/Rich formats
-    if (data['application/vnd.plotly.v1+json']) {
-      result.chart = extractPlotlyChart(data['application/vnd.plotly.v1+json']);
-      result.json = data['application/vnd.plotly.v1+json'];
-    }
-    
-    if (data['application/vnd.vega.v5+json']) {
-      result.chart = extractVegaChart(data['application/vnd.vega.v5+json'], 'vega');
-      result.json = data['application/vnd.vega.v5+json'];
-    }
-    
-    if (data['application/vnd.vegalite.v4+json'] || data['application/vnd.vegalite.v5+json']) {
-      const vegaData = data['application/vnd.vegalite.v4+json'] || data['application/vnd.vegalite.v5+json'];
-      result.chart = extractVegaChart(vegaData, 'vega-lite');
-      result.json = vegaData;
-    }
-    
-    // HTML content (tables, formatted output)
-    if (data['text/html']) {
-      result.html = data['text/html'];
-      
-      // Check if it's a pandas DataFrame
-      if (isPandasDataFrame(data['text/html'])) {
-        result.data = { type: 'dataframe', html: data['text/html'] };
-      }
-    }
-    
-    // Images
-    if (data['image/png']) {
-      result.png = data['image/png'];
-      
-      // Try to detect if it's a chart
-      if (isLikelyChart(data, metadata)) {
-        result.chart = {
-          type: 'unknown',
-          library: 'matplotlib',
-          data: { image: data['image/png'] }
-        };
-      }
-    }
-    
-    if (data['image/jpeg']) {
-      result.jpeg = data['image/jpeg'];
-    }
-    
-    if (data['image/svg+xml']) {
-      result.svg = data['image/svg+xml'];
-    }
-    
-    // Mathematical content
-    if (data['text/latex']) {
-      result.latex = data['text/latex'];
-    }
-    
-    // Code
-    if (data['application/javascript']) {
-      result.javascript = data['application/javascript'];
-    }
-    
-    // Structured data
-    if (data['application/json']) {
-      result.json = data['application/json'];
-    }
-    
-    // Markdown
-    if (data['text/markdown']) {
-      result.markdown = data['text/markdown'];
-    }
-    
-    // Plain text (fallback)
-    if (data['text/plain']) {
-      result.text = data['text/plain'];
-    }
-    
-    return result;
-  }
-
-function extractPlotlyChart(plotlyData: any): ChartData {
-    const data = plotlyData.data || plotlyData;
-    const layout = plotlyData.layout || {};
-    
-    // Try to detect chart type from traces
-    let chartType: ChartData['type'] = 'unknown';
-    if (data && data.length > 0) {
-      const firstTrace = data[0];
-      if (firstTrace.type === 'scatter') {
-        chartType = firstTrace.mode?.includes('lines') ? 'line' : 'scatter';
-      } else if (firstTrace.type === 'bar') {
-        chartType = 'bar';
-      } else if (firstTrace.type === 'pie') {
-        chartType = 'pie';
-      } else if (firstTrace.type === 'histogram') {
-        chartType = 'histogram';
-      } else if (firstTrace.type === 'heatmap') {
-        chartType = 'heatmap';
-      }
-    }
-    
-    return {
-      type: chartType,
-      title: layout.title?.text || layout.title,
-      data: data,
-      layout: layout,
-      config: plotlyData.config,
-      library: 'plotly'
-    };
-  }
-
-function extractVegaChart(vegaData: any, format: 'vega' | 'vega-lite'): ChartData {
-    // Try to detect chart type from mark or encoding
-    let chartType: ChartData['type'] = 'unknown';
-    
-    if (format === 'vega-lite' && vegaData.mark) {
-      const mark = typeof vegaData.mark === 'string' ? vegaData.mark : vegaData.mark.type;
-      switch (mark) {
-        case 'line':
-          chartType = 'line';
-          break;
-        case 'bar':
-          chartType = 'bar';
-          break;
-        case 'point':
-        case 'circle':
-          chartType = 'scatter';
-          break;
-        case 'arc':
-          chartType = 'pie';
-          break;
-        case 'rect':
-          if (vegaData.encoding?.color) {
-            chartType = 'heatmap';
-          }
-          break;
-      }
-    }
-    
-    return {
-      type: chartType,
-      title: vegaData.title,
-      data: vegaData,
-      library: 'altair' // Altair outputs Vega-Lite
-    };
-  }
-
-function isPandasDataFrame(html: string): boolean {
-    // Simple heuristic to detect pandas DataFrame HTML
-    return html.includes('dataframe') || 
-           (html.includes('<table') && html.includes('<thead') && html.includes('<tbody'));
-  }
-
-function isLikelyChart(data: any, metadata?: any): boolean {
-    // Check metadata for hints
-    if (metadata?.needs?.includes('matplotlib')) {
-      return true;
-    }
-    
-    // Check if other chart formats are present
-    if (data['application/vnd.plotly.v1+json'] || 
-        data['application/vnd.vega.v5+json'] ||
-        data['application/vnd.vegalite.v4+json']) {
-      return true;
-    }
-    
-    // If only image output without text, likely a chart
-    if ((data['image/png'] || data['image/svg+xml']) && !data['text/plain']) {
-      return true;
-    }
-    
-    return false;
-  }
-
-export function extractFormats(result: ExecutionResult): string[] {
-    const formats: string[] = [];
-    
-    if (result.text) formats.push('text');
-    if (result.html) formats.push('html');
-    if (result.png) formats.push('png');
-    if (result.jpeg) formats.push('jpeg');
-    if (result.svg) formats.push('svg');
-    if (result.latex) formats.push('latex');
-    if (result.markdown) formats.push('markdown');
-    if (result.javascript) formats.push('javascript');
-    if (result.json) formats.push('json');
-    if (result.chart) formats.push('chart');
-    
-    return formats;
-  }

package/container_src/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "sandbox-server",
-  "version": "1.0.0",
-  "description": "A server for the sandbox package",
-  "main": "index.ts",
-  "scripts": {
-    "start": "bun run index.ts"
-  },
-  "dependencies": {
-    "@jupyterlab/services": "^7.0.0",
-    "ws": "^8.16.0",
-    "uuid": "^9.0.1"
-  },
-  "devDependencies": {
-    "@types/ws": "^8.5.10",
-    "@types/uuid": "^9.0.7"
-  }
-}

package/container_src/shell-escape.ts

@@ -1,42 +0,0 @@
-/**
- * Secure shell command utilities to prevent injection attacks
- */
-
-/**
- * Escapes a string for safe use in shell commands.
- * This follows POSIX shell escaping rules to prevent command injection.
- * 
- * @param str - The string to escape
- * @returns The escaped string safe for shell use
- */
-export function escapeShellArg(str: string): string {
-  // If string is empty, return empty quotes
-  if (str === '') {
-    return "''";
-  }
-
-  // Check if string contains any characters that need escaping
-  // Safe characters: alphanumeric, dash, underscore, dot, slash
-  if (/^[a-zA-Z0-9._\-/]+$/.test(str)) {
-    return str;
-  }
-
-  // For strings with special characters, use single quotes and escape single quotes
-  // Single quotes preserve all characters literally except the single quote itself
-  // To include a single quote, we end the quoted string, add an escaped quote, and start a new quoted string
-  return `'${str.replace(/'/g, "'\\''")}'`;
-}
-
-/**
- * Escapes a file path for safe use in shell commands.
- * 
- * @param path - The file path to escape
- * @returns The escaped path safe for shell use
- */
-export function escapeShellPath(path: string): string {
-  // Normalize path to prevent issues with multiple slashes
-  const normalizedPath = path.replace(/\/+/g, '/');
-  
-  // Apply standard shell escaping
-  return escapeShellArg(normalizedPath);
-}

package/container_src/startup.sh

@@ -1,84 +0,0 @@
-#!/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
-}
-
-# 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"
-}
-
-# 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)
-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

package/container_src/types.ts

@@ -1,131 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-
-// Process management types
-export type ProcessStatus =
-  | 'starting'
-  | 'running'
-  | 'completed'
-  | 'failed'
-  | 'killed'
-  | 'error';
-
-export interface ProcessRecord {
-  id: string;
-  pid?: number;
-  command: string;
-  status: ProcessStatus;
-  startTime: Date;
-  endTime?: Date;
-  exitCode?: number;
-  stdoutFile?: string;  // Path to temp file containing stdout
-  stderrFile?: string;  // Path to temp file containing stderr
-  stdout: string;
-  stderr: string;
-  outputListeners: Set<(stream: 'stdout' | 'stderr', data: string) => void>;
-  statusListeners: Set<(status: ProcessStatus) => void>;
-  monitoringInterval?: NodeJS.Timeout;  // For polling temp files when streaming
-}
-
-export interface StartProcessRequest {
-  command: string;
-  sessionId: string;
-  options?: {
-    processId?: string;
-    timeout?: number;
-    env?: Record<string, string>;
-    cwd?: string;
-    encoding?: string;
-    autoCleanup?: boolean;
-  };
-}
-
-export interface ExecuteOptions {
-  background?: boolean;
-  cwd?: string | URL;
-  env?: Record<string, string>;
-}
-
-export interface ExecuteRequest extends ExecuteOptions {
-  command: string;
-  sessionId: string;
-}
-
-export interface GitCheckoutRequest {
-  repoUrl: string;
-  branch?: string;
-  targetDir?: string;
-  sessionId: string;
-}
-
-export interface MkdirRequest {
-  path: string;
-  recursive?: boolean;
-  sessionId: string;
-}
-
-export interface WriteFileRequest {
-  path: string;
-  content: string;
-  encoding?: string;
-  sessionId: string;
-}
-
-export interface ReadFileRequest {
-  path: string;
-  encoding?: string;
-  sessionId: string;
-}
-
-export interface DeleteFileRequest {
-  path: string;
-  sessionId: string;
-}
-
-export interface RenameFileRequest {
-  oldPath: string;
-  newPath: string;
-  sessionId: string;
-}
-
-export interface MoveFileRequest {
-  sourcePath: string;
-  destinationPath: string;
-  sessionId: string;
-}
-
-export interface ListFilesRequest {
-  path: string;
-  options?: {
-    recursive?: boolean;
-    includeHidden?: boolean;
-  };
-  sessionId: string;
-}
-
-export interface ExposePortRequest {
-  port: number;
-  name?: string;
-}
-
-export interface UnexposePortRequest {
-  port: number;
-}
-
-export interface SessionData {
-  id: string;
-  activeProcess: ChildProcess | null;
-  createdAt: Date;
-}
-
-// Session management API types
-export interface CreateSessionRequest {
-  id: string;
-  env?: Record<string, string>;
-  cwd?: string;
-  isolation?: boolean;
-}
-
-export interface SessionExecRequest {
-  id: string;
-  command: string;
-}