@cloudflare/sandbox 0.0.0-b706463 → 0.0.0-bb855ca

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,52 @@
+#!/bin/bash
+
+# Start Jupyter notebook server in background
+echo "[Startup] Starting Jupyter server..."
+jupyter notebook \
+  --ip=0.0.0.0 \
+  --port=8888 \
+  --no-browser \
+  --allow-root \
+  --NotebookApp.token='' \
+  --NotebookApp.password='' \
+  --NotebookApp.allow_origin='*' \
+  --NotebookApp.disable_check_xsrf=True \
+  --NotebookApp.allow_remote_access=True \
+  --NotebookApp.allow_credentials=True \
+  > /tmp/jupyter.log 2>&1 &
+
+JUPYTER_PID=$!
+
+# Wait for Jupyter to be ready
+echo "[Startup] Waiting for Jupyter to become ready..."
+MAX_ATTEMPTS=30
+ATTEMPT=0
+
+while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
+  if curl -s http://localhost:8888/api > /dev/null 2>&1; then
+    echo "[Startup] Jupyter server is ready!"
+    break
+  fi
+  
+  # Check if Jupyter process is still running
+  if ! kill -0 $JUPYTER_PID 2>/dev/null; then
+    echo "[Startup] ERROR: Jupyter process died. Check /tmp/jupyter.log for details"
+    cat /tmp/jupyter.log
+    exit 1
+  fi
+  
+  ATTEMPT=$((ATTEMPT + 1))
+  echo "[Startup] Waiting for Jupyter... (attempt $ATTEMPT/$MAX_ATTEMPTS)"
+  sleep 1
+done
+
+if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
+  echo "[Startup] ERROR: Jupyter failed to start within 30 seconds"
+  echo "[Startup] Jupyter logs:"
+  cat /tmp/jupyter.log
+  exit 1
+fi
+
+# Start the main Bun server
+echo "[Startup] Starting Bun server..."
+exec bun index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/sandbox",
-  "version": "0.0.0-b706463",
+  "version": "0.0.0-bb855ca",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudflare/sandbox-sdk"

package/src/client.ts

@@ -6,7 +6,7 @@ import type {
   GetProcessResponse,
   ListProcessesResponse,
   StartProcessRequest,
-  StartProcessResponse
+  StartProcessResponse,
 } from "./types";
 
 export interface ExecuteResponse {
@@ -18,22 +18,6 @@ export interface ExecuteResponse {
   timestamp: string;
 }
 
-interface SessionResponse {
-  sessionId: string;
-  message: string;
-  timestamp: string;
-}
-
-interface SessionListResponse {
-  sessions: Array<{
-    sessionId: string;
-    hasActiveProcess: boolean;
-    createdAt: string;
-  }>;
-  count: number;
-  timestamp: string;
-}
-
 interface CommandsResponse {
   availableCommands: string[];
   timestamp: string;
@@ -209,7 +193,7 @@ export class HttpClient {
     this.baseUrl = this.options.baseUrl!;
   }
 
-  private async doFetch(
+  protected async doFetch(
     path: string,
     options?: RequestInit
   ): Promise<Response> {
@@ -252,7 +236,7 @@ export class HttpClient {
 
   async execute(
     command: string,
-    options: Pick<BaseExecOptions, 'sessionId' | 'cwd' | 'env'>
+    options: Pick<BaseExecOptions, "sessionId" | "cwd" | "env">
   ): Promise<ExecuteResponse> {
     try {
       const targetSessionId = options.sessionId || this.sessionId;
@@ -305,7 +289,6 @@ export class HttpClient {
     }
   }
 
-
   async executeCommandStream(
     command: string,
     sessionId?: string
@@ -320,7 +303,7 @@ export class HttpClient {
         }),
         headers: {
           "Content-Type": "application/json",
-          "Accept": "text/event-stream",
+          Accept: "text/event-stream",
         },
         method: "POST",
       });
@@ -338,9 +321,7 @@ export class HttpClient {
         throw new Error("No response body for streaming request");
       }
 
-      console.log(
-        `[HTTP Client] Started command stream: ${command}`
-      );
+      console.log(`[HTTP Client] Started command stream: ${command}`);
 
       return response.body;
     } catch (error) {
@@ -392,7 +373,6 @@ export class HttpClient {
     }
   }
 
-
   async mkdir(
     path: string,
     recursive: boolean = false,
@@ -434,7 +414,6 @@ export class HttpClient {
     }
   }
 
-
   async writeFile(
     path: string,
     content: string,
@@ -478,7 +457,6 @@ export class HttpClient {
     }
   }
 
-
   async readFile(
     path: string,
     encoding: string = "utf-8",
@@ -520,7 +498,6 @@ export class HttpClient {
     }
   }
 
-
   async deleteFile(
     path: string,
     sessionId?: string
@@ -560,7 +537,6 @@ export class HttpClient {
     }
   }
 
-
   async renameFile(
     oldPath: string,
     newPath: string,
@@ -602,7 +578,6 @@ export class HttpClient {
     }
   }
 
-
   async moveFile(
     sourcePath: string,
     destinationPath: string,
@@ -644,7 +619,6 @@ export class HttpClient {
     }
   }
 
-
   async exposePort(port: number, name?: string): Promise<ExposePortResponse> {
     try {
       const response = await this.doFetch(`/api/expose-port`, {
@@ -670,7 +644,9 @@ export class HttpClient {
 
       const data: ExposePortResponse = await response.json();
       console.log(
-        `[HTTP Client] Port exposed: ${port}${name ? ` (${name})` : ""}, Success: ${data.success}`
+        `[HTTP Client] Port exposed: ${port}${
+          name ? ` (${name})` : ""
+        }, Success: ${data.success}`
       );
 
       return data;
@@ -732,9 +708,7 @@ export class HttpClient {
       }
 
       const data: GetExposedPortsResponse = await response.json();
-      console.log(
-        `[HTTP Client] Got ${data.count} exposed ports`
-      );
+      console.log(`[HTTP Client] Got ${data.count} exposed ports`);
 
       return data;
     } catch (error) {
@@ -871,9 +845,7 @@ export class HttpClient {
       }
 
       const data: ListProcessesResponse = await response.json();
-      console.log(
-        `[HTTP Client] Listed ${data.processes.length} processes`
-      );
+      console.log(`[HTTP Client] Listed ${data.processes.length} processes`);
 
       return data;
     } catch (error) {
@@ -902,7 +874,9 @@ export class HttpClient {
 
       const data: GetProcessResponse = await response.json();
       console.log(
-        `[HTTP Client] Got process ${processId}: ${data.process?.status || 'not found'}`
+        `[HTTP Client] Got process ${processId}: ${
+          data.process?.status || "not found"
+        }`
       );
 
       return data;
@@ -912,7 +886,9 @@ export class HttpClient {
     }
   }
 
-  async killProcess(processId: string): Promise<{ success: boolean; message: string }> {
+  async killProcess(
+    processId: string
+  ): Promise<{ success: boolean; message: string }> {
     try {
       const response = await this.doFetch(`/api/process/${processId}`, {
         headers: {
@@ -930,10 +906,11 @@ export class HttpClient {
         );
       }
 
-      const data = await response.json() as { success: boolean; message: string };
-      console.log(
-        `[HTTP Client] Killed process ${processId}`
-      );
+      const data = (await response.json()) as {
+        success: boolean;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed process ${processId}`);
 
       return data;
     } catch (error) {
@@ -942,7 +919,11 @@ export class HttpClient {
     }
   }
 
-  async killAllProcesses(): Promise<{ success: boolean; killedCount: number; message: string }> {
+  async killAllProcesses(): Promise<{
+    success: boolean;
+    killedCount: number;
+    message: string;
+  }> {
     try {
       const response = await this.doFetch("/api/process/kill-all", {
         headers: {
@@ -960,10 +941,12 @@ export class HttpClient {
         );
       }
 
-      const data = await response.json() as { success: boolean; killedCount: number; message: string };
-      console.log(
-        `[HTTP Client] Killed ${data.killedCount} processes`
-      );
+      const data = (await response.json()) as {
+        success: boolean;
+        killedCount: number;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed ${data.killedCount} processes`);
 
       return data;
     } catch (error) {
@@ -991,9 +974,7 @@ export class HttpClient {
       }
 
       const data: GetProcessLogsResponse = await response.json();
-      console.log(
-        `[HTTP Client] Got logs for process ${processId}`
-      );
+      console.log(`[HTTP Client] Got logs for process ${processId}`);
 
       return data;
     } catch (error) {
@@ -1002,11 +983,13 @@ export class HttpClient {
     }
   }
 
-  async streamProcessLogs(processId: string): Promise<ReadableStream<Uint8Array>> {
+  async streamProcessLogs(
+    processId: string
+  ): Promise<ReadableStream<Uint8Array>> {
     try {
       const response = await this.doFetch(`/api/process/${processId}/stream`, {
         headers: {
-          "Accept": "text/event-stream",
+          Accept: "text/event-stream",
           "Cache-Control": "no-cache",
         },
         method: "GET",

package/src/index.ts

@@ -5,16 +5,25 @@ export type {
   MkdirResponse, MoveFileResponse,
   ReadFileResponse, RenameFileResponse, WriteFileResponse
 } from "./client";
-
+// Export code interpreter types
+export type {
+  ChartData, 
+  CodeContext,
+  CreateContextOptions,
+  Execution,
+  ExecutionError,
+  OutputMessage,
+  Result,
+  RunCodeOptions
+} from "./interpreter-types";
+// Export the implementations
+export { ResultImpl } from "./interpreter-types";
 // Re-export request handler utilities
 export {
   proxyToSandbox, type RouteInfo, type SandboxEnv
 } from './request-handler';
-
 export { getSandbox, Sandbox } from "./sandbox";
-
 // Export SSE parser for converting ReadableStream to AsyncIterable
 export { asyncIterableToSSEStream, parseSSEStream, responseToAsyncIterable } from "./sse-parser";
-
 // Export event types for streaming
 export type { ExecEvent, LogEvent } from "./types";