@cloudflare/sandbox 0.0.0-bb855ca → 0.0.0-c1f057e

package/src/interpreter-types.ts

@@ -1,383 +0,0 @@
-// Context Management
-export interface CreateContextOptions {
-  /**
-   * Programming language for the context
-   * @default 'python'
-   */
-  language?: 'python' | 'javascript' | 'typescript';
-  
-  /**
-   * Working directory for the context
-   * @default '/workspace'
-   */
-  cwd?: string;
-  
-  /**
-   * Environment variables for the context
-   */
-  envVars?: Record<string, string>;
-  
-  /**
-   * Request timeout in milliseconds
-   * @default 30000
-   */
-  timeout?: number;
-}
-
-export interface CodeContext {
-  /**
-   * Unique identifier for the context
-   */
-  readonly id: string;
-  
-  /**
-   * Programming language of the context
-   */
-  readonly language: string;
-  
-  /**
-   * Current working directory
-   */
-  readonly cwd: string;
-  
-  /**
-   * When the context was created
-   */
-  readonly createdAt: Date;
-  
-  /**
-   * When the context was last used
-   */
-  readonly lastUsed: Date;
-}
-
-// Execution Options
-export interface RunCodeOptions {
-  /**
-   * Context to run the code in. If not provided, uses default context for the language
-   */
-  context?: CodeContext;
-  
-  /**
-   * Language to use if context is not provided
-   * @default 'python'
-   */
-  language?: 'python' | 'javascript' | 'typescript';
-  
-  /**
-   * Environment variables for this execution
-   */
-  envVars?: Record<string, string>;
-  
-  /**
-   * Execution timeout in milliseconds
-   * @default 60000
-   */
-  timeout?: number;
-  
-  /**
-   * AbortSignal for cancelling execution
-   */
-  signal?: AbortSignal;
-  
-  /**
-   * Callback for stdout output
-   */
-  onStdout?: (output: OutputMessage) => void | Promise<void>;
-  
-  /**
-   * Callback for stderr output
-   */
-  onStderr?: (output: OutputMessage) => void | Promise<void>;
-  
-  /**
-   * Callback for execution results (charts, tables, etc)
-   */
-  onResult?: (result: Result) => void | Promise<void>;
-  
-  /**
-   * Callback for execution errors
-   */
-  onError?: (error: ExecutionError) => void | Promise<void>;
-}
-
-// Output Messages
-export interface OutputMessage {
-  /**
-   * The output text
-   */
-  text: string;
-  
-  /**
-   * Timestamp of the output
-   */
-  timestamp: number;
-}
-
-// Execution Results
-export interface Result {
-  /**
-   * Plain text representation
-   */
-  text?: string;
-  
-  /**
-   * HTML representation (tables, formatted output)
-   */
-  html?: string;
-  
-  /**
-   * PNG image data (base64 encoded)
-   */
-  png?: string;
-  
-  /**
-   * JPEG image data (base64 encoded)
-   */
-  jpeg?: string;
-  
-  /**
-   * SVG image data
-   */
-  svg?: string;
-  
-  /**
-   * LaTeX representation
-   */
-  latex?: string;
-  
-  /**
-   * Markdown representation
-   */
-  markdown?: string;
-  
-  /**
-   * JavaScript code to execute
-   */
-  javascript?: string;
-  
-  /**
-   * JSON data
-   */
-  json?: any;
-  
-  /**
-   * Chart data if the result is a visualization
-   */
-  chart?: ChartData;
-  
-  /**
-   * Raw data object
-   */
-  data?: any;
-  
-  /**
-   * Available output formats
-   */
-  formats(): string[];
-}
-
-// Chart Data
-export interface ChartData {
-  /**
-   * Type of chart
-   */
-  type: 'line' | 'bar' | 'scatter' | 'pie' | 'histogram' | 'heatmap' | 'unknown';
-  
-  /**
-   * Chart title
-   */
-  title?: string;
-  
-  /**
-   * Chart data (format depends on library)
-   */
-  data: any;
-  
-  /**
-   * Chart layout/configuration
-   */
-  layout?: any;
-  
-  /**
-   * Additional configuration
-   */
-  config?: any;
-  
-  /**
-   * Library that generated the chart
-   */
-  library?: 'matplotlib' | 'plotly' | 'altair' | 'seaborn' | 'unknown';
-  
-  /**
-   * Base64 encoded image if available
-   */
-  image?: string;
-}
-
-// Execution Error
-export interface ExecutionError {
-  /**
-   * Error name/type (e.g., 'NameError', 'SyntaxError')
-   */
-  name: string;
-  
-  /**
-   * Error message
-   */
-  value: string;
-  
-  /**
-   * Stack trace
-   */
-  traceback: string[];
-  
-  /**
-   * Line number where error occurred
-   */
-  lineNumber?: number;
-}
-
-// Serializable execution result
-export interface ExecutionResult {
-  code: string;
-  logs: {
-    stdout: string[];
-    stderr: string[];
-  };
-  error?: ExecutionError;
-  executionCount?: number;
-  results: Array<{
-    text?: string;
-    html?: string;
-    png?: string;
-    jpeg?: string;
-    svg?: string;
-    latex?: string;
-    markdown?: string;
-    javascript?: string;
-    json?: any;
-    chart?: ChartData;
-    data?: any;
-  }>;
-}
-
-// Execution Result Container
-export class Execution {
-  /**
-   * All results from the execution
-   */
-  public results: Result[] = [];
-  
-  /**
-   * Accumulated stdout and stderr
-   */
-  public logs = {
-    stdout: [] as string[],
-    stderr: [] as string[]
-  };
-  
-  /**
-   * Execution error if any
-   */
-  public error?: ExecutionError;
-  
-  /**
-   * Execution count (for Jupyter)
-   */
-  public executionCount?: number;
-  
-  constructor(
-    public readonly code: string,
-    public readonly context: CodeContext
-  ) {}
-  
-  /**
-   * Convert to a plain object for serialization
-   */
-  toJSON(): ExecutionResult {
-    return {
-      code: this.code,
-      logs: this.logs,
-      error: this.error,
-      executionCount: this.executionCount,
-      results: this.results.map(result => ({
-        text: result.text,
-        html: result.html,
-        png: result.png,
-        jpeg: result.jpeg,
-        svg: result.svg,
-        latex: result.latex,
-        markdown: result.markdown,
-        javascript: result.javascript,
-        json: result.json,
-        chart: result.chart,
-        data: result.data
-      }))
-    };
-  }
-}
-
-// Implementation of Result
-export class ResultImpl implements Result {
-  constructor(private raw: any) {}
-  
-  get text(): string | undefined { 
-    return this.raw.text || this.raw.data?.['text/plain']; 
-  }
-  
-  get html(): string | undefined { 
-    return this.raw.html || this.raw.data?.['text/html']; 
-  }
-  
-  get png(): string | undefined { 
-    return this.raw.png || this.raw.data?.['image/png']; 
-  }
-  
-  get jpeg(): string | undefined { 
-    return this.raw.jpeg || this.raw.data?.['image/jpeg']; 
-  }
-  
-  get svg(): string | undefined { 
-    return this.raw.svg || this.raw.data?.['image/svg+xml']; 
-  }
-  
-  get latex(): string | undefined { 
-    return this.raw.latex || this.raw.data?.['text/latex']; 
-  }
-  
-  get markdown(): string | undefined { 
-    return this.raw.markdown || this.raw.data?.['text/markdown']; 
-  }
-  
-  get javascript(): string | undefined { 
-    return this.raw.javascript || this.raw.data?.['application/javascript']; 
-  }
-  
-  get json(): any { 
-    return this.raw.json || this.raw.data?.['application/json']; 
-  }
-  
-  get chart(): ChartData | undefined { 
-    return this.raw.chart; 
-  }
-  
-  get data(): any { 
-    return this.raw.data; 
-  }
-  
-  formats(): string[] {
-    const formats: string[] = [];
-    if (this.text) formats.push('text');
-    if (this.html) formats.push('html');
-    if (this.png) formats.push('png');
-    if (this.jpeg) formats.push('jpeg');
-    if (this.svg) formats.push('svg');
-    if (this.latex) formats.push('latex');
-    if (this.markdown) formats.push('markdown');
-    if (this.javascript) formats.push('javascript');
-    if (this.json) formats.push('json');
-    if (this.chart) formats.push('chart');
-    return formats;
-  }
-}

package/src/jupyter-client.ts

@@ -1,266 +0,0 @@
-import { HttpClient } from './client.js';
-import type { 
-  CodeContext, 
-  CreateContextOptions, 
-  ExecutionError, 
-  OutputMessage,
-  Result
-} from './interpreter-types.js';
-
-// API Response types
-interface ContextResponse {
-  id: string;
-  language: string;
-  cwd: string;
-  createdAt: string;  // ISO date string from JSON
-  lastUsed: string;   // ISO date string from JSON
-}
-
-interface ContextListResponse {
-  contexts: ContextResponse[];
-}
-
-interface ErrorResponse {
-  error: string;
-}
-
-// Streaming execution data from the server
-interface StreamingExecutionData {
-  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?: any;
-  data?: any;
-  metadata?: any;
-  execution_count?: number;
-  ename?: string;
-  evalue?: string;
-  traceback?: string[];
-  lineNumber?: number;
-  timestamp?: number;
-}
-
-export interface ExecutionCallbacks {
-  onStdout?: (output: OutputMessage) => void | Promise<void>;
-  onStderr?: (output: OutputMessage) => void | Promise<void>;
-  onResult?: (result: Result) => void | Promise<void>;
-  onError?: (error: ExecutionError) => void | Promise<void>;
-}
-
-export class JupyterClient extends HttpClient {
-  async createCodeContext(options: CreateContextOptions = {}): Promise<CodeContext> {
-    const response = await this.doFetch('/api/contexts', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        language: options.language || 'python',
-        cwd: options.cwd || '/workspace',
-        env_vars: options.envVars
-      }),
-    });
-    
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({ error: 'Unknown error' })) as ErrorResponse;
-      throw new Error(errorData.error || `Failed to create context: ${response.status}`);
-    }
-    
-    const data = await response.json() as ContextResponse;
-    return {
-      id: data.id,
-      language: data.language,
-      cwd: data.cwd,
-      createdAt: new Date(data.createdAt),
-      lastUsed: new Date(data.lastUsed)
-    };
-  }
-  
-  async runCodeStream(
-    contextId: string | undefined, 
-    code: string, 
-    language: string | undefined,
-    callbacks: ExecutionCallbacks
-  ): Promise<void> {
-    const response = await this.doFetch('/api/execute/code', {
-      method: 'POST',
-      headers: { 
-        'Content-Type': 'application/json',
-        'Accept': 'text/event-stream'
-      },
-      body: JSON.stringify({ 
-        context_id: contextId, 
-        code,
-        language 
-      }),
-    });
-    
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({ error: 'Unknown error' })) as ErrorResponse;
-      throw new Error(errorData.error || `Failed to execute code: ${response.status}`);
-    }
-    
-    if (!response.body) {
-      throw new Error('No response body for streaming execution');
-    }
-    
-    // Process streaming response
-    for await (const chunk of this.readLines(response.body)) {
-      await this.parseExecutionResult(chunk, callbacks);
-    }
-  }
-  
-  private async *readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
-    const reader = stream.getReader();
-    let buffer = '';
-    
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (value) {
-          buffer += new TextDecoder().decode(value);
-        }
-        if (done) break;
-        
-        let newlineIdx = buffer.indexOf('\n');
-        while (newlineIdx !== -1) {
-          yield buffer.slice(0, newlineIdx);
-          buffer = buffer.slice(newlineIdx + 1);
-          newlineIdx = buffer.indexOf('\n');
-        }
-      }
-      
-      // Yield any remaining data
-      if (buffer.length > 0) {
-        yield buffer;
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  
-  private async parseExecutionResult(line: string, callbacks: ExecutionCallbacks) {
-    if (!line.trim()) return;
-    
-    try {
-      const data = JSON.parse(line) as StreamingExecutionData;
-      
-      switch (data.type) {
-        case 'stdout':
-          if (callbacks.onStdout && data.text) {
-            await callbacks.onStdout({
-              text: data.text,
-              timestamp: data.timestamp || Date.now()
-            });
-          }
-          break;
-          
-        case 'stderr':
-          if (callbacks.onStderr && data.text) {
-            await callbacks.onStderr({
-              text: data.text,
-              timestamp: data.timestamp || Date.now()
-            });
-          }
-          break;
-          
-        case 'result':
-          if (callbacks.onResult) {
-            // Convert raw result to Result interface
-            const result: Result = {
-              text: data.text,
-              html: data.html,
-              png: data.png,
-              jpeg: data.jpeg,
-              svg: data.svg,
-              latex: data.latex,
-              markdown: data.markdown,
-              javascript: data.javascript,
-              json: data.json,
-              chart: data.chart,
-              data: data.data,
-              formats: () => {
-                const formats: string[] = [];
-                if (data.text) formats.push('text');
-                if (data.html) formats.push('html');
-                if (data.png) formats.push('png');
-                if (data.jpeg) formats.push('jpeg');
-                if (data.svg) formats.push('svg');
-                if (data.latex) formats.push('latex');
-                if (data.markdown) formats.push('markdown');
-                if (data.javascript) formats.push('javascript');
-                if (data.json) formats.push('json');
-                if (data.chart) formats.push('chart');
-                return formats;
-              }
-            };
-            await callbacks.onResult(result);
-          }
-          break;
-          
-        case 'error':
-          if (callbacks.onError) {
-            await callbacks.onError({
-              name: data.ename || 'Error',
-              value: data.evalue || data.text || 'Unknown error',
-              traceback: data.traceback || [],
-              lineNumber: data.lineNumber
-            });
-          }
-          break;
-          
-        case 'execution_complete':
-          // Execution completed successfully
-          break;
-      }
-    } catch (error) {
-      console.error('[JupyterClient] Error parsing execution result:', error);
-    }
-  }
-  
-  async listCodeContexts(): Promise<CodeContext[]> {
-    const response = await this.doFetch('/api/contexts', {
-      method: 'GET',
-      headers: { 'Content-Type': 'application/json' }
-    });
-    
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({ error: 'Unknown error' })) as ErrorResponse;
-      throw new Error(errorData.error || `Failed to list contexts: ${response.status}`);
-    }
-    
-    const data = await response.json() as ContextListResponse;
-    return data.contexts.map((ctx) => ({
-      id: ctx.id,
-      language: ctx.language,
-      cwd: ctx.cwd,
-      createdAt: new Date(ctx.createdAt),
-      lastUsed: new Date(ctx.lastUsed)
-    }));
-  }
-  
-  async deleteCodeContext(contextId: string): Promise<void> {
-    const response = await this.doFetch(`/api/contexts/${contextId}`, {
-      method: 'DELETE',
-      headers: { 'Content-Type': 'application/json' }
-    });
-    
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({ error: 'Unknown error' })) as ErrorResponse;
-      throw new Error(errorData.error || `Failed to delete context: ${response.status}`);
-    }
-  }
-  
-  // Override parent doFetch to be public for this class
-  public async doFetch(
-    path: string,
-    options?: RequestInit
-  ): Promise<Response> {
-    return super.doFetch(path, options);
-  }
-}