@cloudflare/sandbox 0.0.0-0ac3cfa → 0.0.0-12bbd12

package/container_src/mime-processor.ts

@@ -0,0 +1,255 @@
+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

@@ -5,5 +5,14 @@
   "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/startup.sh

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

@@ -0,0 +1,117 @@
+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;
+  sessionId?: string;
+  childProcess?: ChildProcess;
+  stdout: string;
+  stderr: string;
+  outputListeners: Set<(stream: 'stdout' | 'stderr', data: string) => void>;
+  statusListeners: Set<(status: ProcessStatus) => void>;
+}
+
+export interface StartProcessRequest {
+  command: string;
+  options?: {
+    processId?: string;
+    sessionId?: string;
+    timeout?: number;
+    env?: Record<string, string>;
+    cwd?: string;
+    encoding?: string;
+    autoCleanup?: boolean;
+  };
+}
+
+export interface ExecuteOptions {
+  sessionId?: string | null;
+  background?: boolean;
+  cwd?: string | URL;
+  env?: Record<string, string>;
+}
+
+export interface ExecuteRequest extends ExecuteOptions {
+  command: 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 {
+  sessionId: string;
+  activeProcess: ChildProcess | null;
+  createdAt: Date;
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cloudflare/sandbox",
-  "version": "0.0.0-0ac3cfa",
+  "version": "0.0.0-12bbd12",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudflare/sandbox-sdk"
   },
   "description": "A sandboxed environment for running commands",
   "dependencies": {
-    "@cloudflare/containers": "^0.0.13"
+    "@cloudflare/containers": "^0.0.25"
   },
   "tags": [
     "sandbox",
@@ -18,19 +18,15 @@
   ],
   "scripts": {
     "build": "rm -rf dist && tsup src/*.ts --outDir dist --dts --sourcemap --format esm",
-    "docker:build": "docker build -t ghostwriternr/cloudflare-sandbox:$npm_package_version .",
-    "docker:publish": "docker push docker.io/ghostwriternr/cloudflare-sandbox:$npm_package_version"
+    "docker:local": "docker build . -t cloudflare/sandbox-test:$npm_package_version",
+    "docker:publish": "docker buildx build --platform linux/amd64,linux/arm64 -t cloudflare/sandbox:$npm_package_version --push .",
+    "docker:publish:beta": "docker buildx build --platform linux/amd64,linux/arm64 -t cloudflare/sandbox:$npm_package_version-beta --push ."
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js"
-    },
-    "./client": {
-      "types": "./dist/client.d.ts",
-      "import": "./dist/client.js",
-      "require": "./dist/client.js"
     }
   },
   "keywords": [],