@cloudflare/sandbox 0.0.0-d55b0f4 → 0.0.0-d81d2a5

package/src/client.ts

@@ -1,17 +1,14 @@
+import type { ExecuteRequest } from "../container_src/types";
 import type { Sandbox } from "./index";
 import type {
+  BaseExecOptions,
   GetProcessLogsResponse,
   GetProcessResponse,
   ListProcessesResponse,
   StartProcessRequest,
-  StartProcessResponse
+  StartProcessResponse,
 } from "./types";
 
-interface ExecuteRequest {
-  command: string;
-  sessionId?: string;
-}
-
 export interface ExecuteResponse {
   success: boolean;
   stdout: string;
@@ -21,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;
@@ -212,7 +193,7 @@ export class HttpClient {
     this.baseUrl = this.options.baseUrl!;
   }
 
-  private async doFetch(
+  protected async doFetch(
     path: string,
     options?: RequestInit
   ): Promise<Response> {
@@ -255,16 +236,19 @@ export class HttpClient {
 
   async execute(
     command: string,
-    sessionId?: string
+    options: Pick<BaseExecOptions, "sessionId" | "cwd" | "env">
   ): Promise<ExecuteResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
+      const targetSessionId = options.sessionId || this.sessionId;
+      const executeRequest = {
+        command,
+        sessionId: targetSessionId,
+        cwd: options.cwd,
+        env: options.env,
+      } satisfies ExecuteRequest;
 
       const response = await this.doFetch(`/api/execute`, {
-        body: JSON.stringify({
-          command,
-          sessionId: targetSessionId,
-        } as ExecuteRequest),
+        body: JSON.stringify(executeRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -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";

package/src/interpreter-types.ts

@@ -0,0 +1,383 @@
+// 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;
+  }
+}