@cloudflare/sandbox 0.0.0-bb855ca → 0.0.0-c39674b

package/container_src/jupyter-server.ts

@@ -1,336 +0,0 @@
-import { type Kernel, KernelManager, ServerConnection } from "@jupyterlab/services";
-import type { 
-  IDisplayDataMsg,
-  IErrorMsg, 
-  IExecuteResultMsg,
-  IIOPubMessage,
-  IStreamMsg
-} from "@jupyterlab/services/lib/kernel/messages";
-import { 
-  isDisplayDataMsg,
-  isErrorMsg, 
-  isExecuteResultMsg,
-  isStreamMsg
-} from "@jupyterlab/services/lib/kernel/messages";
-import { v4 as uuidv4 } from "uuid";
-import type { ExecutionResult } from "./mime-processor";
-import { processJupyterMessage } from "./mime-processor";
-
-export interface JupyterContext {
-  id: string;
-  language: string;
-  connection: Kernel.IKernelConnection;
-  cwd: string;
-  createdAt: Date;
-  lastUsed: Date;
-}
-
-export interface CreateContextRequest {
-  language?: string;
-  cwd?: string;
-  envVars?: Record<string, string>;
-}
-
-export interface ExecuteCodeRequest {
-  context_id?: string;
-  code: string;
-  language?: string;
-  env_vars?: Record<string, string>;
-}
-
-export class JupyterServer {
-  private kernelManager: KernelManager;
-  private contexts = new Map<string, JupyterContext>();
-  private defaultContexts = new Map<string, string>(); // language -> context_id
-
-  constructor() {
-    // Configure connection to local Jupyter server
-    const serverSettings = ServerConnection.makeSettings({
-      baseUrl: "http://localhost:8888",
-      token: "",
-      appUrl: "",
-      wsUrl: "ws://localhost:8888",
-      appendToken: false,
-      init: {
-        headers: {
-          'Content-Type': 'application/json'
-        }
-      }
-    });
-
-    this.kernelManager = new KernelManager({ serverSettings });
-  }
-
-  async initialize() {
-    await this.kernelManager.ready;
-    console.log("[JupyterServer] Kernel manager initialized");
-
-    // Create default Python context
-    const pythonContext = await this.createContext({ language: "python" });
-    this.defaultContexts.set("python", pythonContext.id);
-    console.log(
-      "[JupyterServer] Default Python context created:",
-      pythonContext.id
-    );
-  }
-
-  async createContext(req: CreateContextRequest): Promise<JupyterContext> {
-    const language = req.language || "python";
-    const cwd = req.cwd || "/workspace";
-
-    const kernelModel = await this.kernelManager.startNew({
-      name: this.getKernelName(language),
-    });
-
-    const connection = this.kernelManager.connectTo({ model: kernelModel });
-
-    const context: JupyterContext = {
-      id: uuidv4(),
-      language,
-      connection,
-      cwd,
-      createdAt: new Date(),
-      lastUsed: new Date(),
-    };
-
-    this.contexts.set(context.id, context);
-
-    // Set working directory
-    if (cwd !== "/workspace") {
-      await this.changeWorkingDirectory(context, cwd);
-    }
-
-    // Set environment variables if provided
-    if (req.envVars) {
-      await this.setEnvironmentVariables(context, req.envVars);
-    }
-
-    return context;
-  }
-
-  async executeCode(
-    contextId: string | undefined,
-    code: string,
-    language?: string
-  ): Promise<Response> {
-    let context: JupyterContext | undefined;
-
-    if (contextId) {
-      context = this.contexts.get(contextId);
-      if (!context) {
-        return new Response(
-          JSON.stringify({ error: `Context ${contextId} not found` }),
-          {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          }
-        );
-      }
-    } else if (language) {
-      // Use default context for the language
-      const defaultContextId = this.defaultContexts.get(language);
-      if (defaultContextId) {
-        context = this.contexts.get(defaultContextId);
-      }
-
-      // Create new default context if needed
-      if (!context) {
-        context = await this.createContext({ language });
-        this.defaultContexts.set(language, context.id);
-      }
-    } else {
-      // Use default Python context
-      const pythonContextId = this.defaultContexts.get("python");
-      context = pythonContextId
-        ? this.contexts.get(pythonContextId)
-        : undefined;
-    }
-
-    if (!context) {
-      return new Response(JSON.stringify({ error: "No context available" }), {
-        status: 400,
-        headers: { "Content-Type": "application/json" },
-      });
-    }
-
-    // Update last used
-    context.lastUsed = new Date();
-
-    // Execute with streaming
-    return this.streamExecution(context.connection, code);
-  }
-
-  private async streamExecution(
-    connection: Kernel.IKernelConnection,
-    code: string
-  ): Promise<Response> {
-    const stream = new ReadableStream({
-      async start(controller) {
-        const future = connection.requestExecute({
-          code,
-          stop_on_error: false,
-          store_history: true,
-          silent: false,
-          allow_stdin: false,
-        });
-
-        // Handle different message types
-        future.onIOPub = (msg: IIOPubMessage) => {
-          const result = processJupyterMessage(msg);
-          if (result) {
-            controller.enqueue(
-              new TextEncoder().encode(`${JSON.stringify(result)}\n`)
-            );
-          }
-        };
-
-        future.onReply = (msg: any) => {
-          if (msg.content.status === "ok") {
-            controller.enqueue(
-              new TextEncoder().encode(
-                `${JSON.stringify({
-                  type: "execution_complete",
-                  execution_count: msg.content.execution_count,
-                })}\n`
-              )
-            );
-          } else if (msg.content.status === "error") {
-            controller.enqueue(
-              new TextEncoder().encode(
-                `${JSON.stringify({
-                  type: "error",
-                  ename: msg.content.ename,
-                  evalue: msg.content.evalue,
-                  traceback: msg.content.traceback,
-                })}\n`
-              )
-            );
-          }
-          controller.close();
-        };
-
-        future.onStdin = (msg: any) => {
-          // We don't support stdin for now
-          console.warn("[JupyterServer] Stdin requested but not supported");
-        };
-      },
-    });
-
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-      },
-    });
-  }
-
-  private getKernelName(language: string): string {
-    const kernelMap: Record<string, string> = {
-      python: "python3",
-      javascript: "javascript",
-      typescript: "javascript",
-      js: "javascript",
-      ts: "javascript",
-    };
-    return kernelMap[language.toLowerCase()] || "python3";
-  }
-
-  private async changeWorkingDirectory(context: JupyterContext, cwd: string) {
-    const code =
-      context.language === "python"
-        ? `import os; os.chdir('${cwd}')`
-        : `process.chdir('${cwd}')`;
-
-    const future = context.connection.requestExecute({
-      code,
-      silent: true,
-      store_history: false,
-    });
-
-    return future.done;
-  }
-
-  private async setEnvironmentVariables(
-    context: JupyterContext,
-    envVars: Record<string, string>
-  ) {
-    const commands: string[] = [];
-
-    for (const [key, value] of Object.entries(envVars)) {
-      if (context.language === "python") {
-        commands.push(`import os; os.environ['${key}'] = '${value}'`);
-      } else if (
-        context.language === "javascript" ||
-        context.language === "typescript"
-      ) {
-        commands.push(`process.env['${key}'] = '${value}'`);
-      }
-    }
-
-    if (commands.length > 0) {
-      const code = commands.join("\n");
-      const future = context.connection.requestExecute({
-        code,
-        silent: true,
-        store_history: false,
-      });
-
-      return future.done;
-    }
-  }
-
-  async listContexts(): Promise<
-    Array<{
-      id: string;
-      language: string;
-      cwd: string;
-      createdAt: Date;
-      lastUsed: Date;
-    }>
-  > {
-    return Array.from(this.contexts.values()).map((ctx) => ({
-      id: ctx.id,
-      language: ctx.language,
-      cwd: ctx.cwd,
-      createdAt: ctx.createdAt,
-      lastUsed: ctx.lastUsed,
-    }));
-  }
-
-  async deleteContext(contextId: string): Promise<void> {
-    const context = this.contexts.get(contextId);
-    if (!context) {
-      throw new Error(`Context ${contextId} not found`);
-    }
-
-    // Shutdown the kernel
-    await context.connection.shutdown();
-
-    // Remove from maps
-    this.contexts.delete(contextId);
-
-    // Remove from default contexts if it was a default
-    for (const [lang, id] of this.defaultContexts.entries()) {
-      if (id === contextId) {
-        this.defaultContexts.delete(lang);
-        break;
-      }
-    }
-  }
-
-  async shutdown() {
-    // Shutdown all kernels
-    for (const context of this.contexts.values()) {
-      try {
-        await context.connection.shutdown();
-      } catch (error) {
-        console.error("[JupyterServer] Error shutting down kernel:", error);
-      }
-    }
-
-    this.contexts.clear();
-    this.defaultContexts.clear();
-  }
-}
-

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/startup.sh

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