@cloudflare/sandbox 0.0.0-603d05f → 0.0.0-66cc85b

package/src/interpreter.ts

@@ -1,3 +1,4 @@
+import type { InterpreterClient } from "./interpreter-client.js";
 import {
   type CodeContext,
   type CreateContextOptions,
@@ -5,15 +6,14 @@ import {
   ResultImpl,
   type RunCodeOptions,
 } from "./interpreter-types.js";
-import type { JupyterClient } from "./jupyter-client.js";
 import type { Sandbox } from "./sandbox.js";
 
 export class CodeInterpreter {
-  private jupyterClient: JupyterClient;
+  private interpreterClient: InterpreterClient;
   private contexts = new Map<string, CodeContext>();
 
   constructor(sandbox: Sandbox) {
-    this.jupyterClient = sandbox.client as JupyterClient;
+    this.interpreterClient = sandbox.client as InterpreterClient;
   }
 
   /**
@@ -22,7 +22,7 @@ export class CodeInterpreter {
   async createCodeContext(
     options: CreateContextOptions = {}
   ): Promise<CodeContext> {
-    const context = await this.jupyterClient.createCodeContext(options);
+    const context = await this.interpreterClient.createCodeContext(options);
     this.contexts.set(context.id, context);
     return context;
   }
@@ -46,7 +46,7 @@ export class CodeInterpreter {
     const execution = new Execution(code, context);
 
     // Stream execution
-    await this.jupyterClient.runCodeStream(context.id, code, options.language, {
+    await this.interpreterClient.runCodeStream(context.id, code, options.language, {
       onStdout: (output) => {
         execution.logs.stdout.push(output.text);
         if (options.onStdout) return options.onStdout(output);
@@ -83,7 +83,7 @@ export class CodeInterpreter {
     }
 
     // Create streaming response
-    const response = await this.jupyterClient.doFetch("/api/execute/code", {
+    const response = await this.interpreterClient.doFetch("/api/execute/code", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -116,7 +116,7 @@ export class CodeInterpreter {
    * List all code contexts
    */
   async listCodeContexts(): Promise<CodeContext[]> {
-    const contexts = await this.jupyterClient.listCodeContexts();
+    const contexts = await this.interpreterClient.listCodeContexts();
 
     // Update local cache
     for (const context of contexts) {
@@ -130,7 +130,7 @@ export class CodeInterpreter {
    * Delete a code context
    */
   async deleteCodeContext(contextId: string): Promise<void> {
-    await this.jupyterClient.deleteCodeContext(contextId);
+    await this.interpreterClient.deleteCodeContext(contextId);
     this.contexts.delete(contextId);
   }
 

package/src/sandbox.ts

@@ -1,12 +1,12 @@
 import { Container, getContainer } from "@cloudflare/containers";
 import { CodeInterpreter } from "./interpreter";
+import { InterpreterClient } from "./interpreter-client";
 import type {
   CodeContext,
   CreateContextOptions,
   ExecutionResult,
   RunCodeOptions,
 } from "./interpreter-types";
-import { JupyterClient } from "./jupyter-client";
 import { isLocalhostPattern } from "./request-handler";
 import {
   logSecurityEvent,
@@ -41,14 +41,14 @@ export function getSandbox(ns: DurableObjectNamespace<Sandbox>, id: string) {
 export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
   defaultPort = 3000; // Default port for the container's Bun server
   sleepAfter = "20m"; // Keep container warm for 20 minutes to avoid cold starts
-  client: JupyterClient;
+  client: InterpreterClient;
   private sandboxName: string | null = null;
   private codeInterpreter: CodeInterpreter;
   private defaultSession: ExecutionSession | null = null;
 
-  constructor(ctx: DurableObjectState, env: Env) {
+  constructor(ctx: DurableObjectState<{}>, env: Env) {
     super(ctx, env);
-    this.client = new JupyterClient({
+    this.client = new InterpreterClient({
       onCommandComplete: (success, exitCode, _stdout, _stderr, command) => {
         console.log(
           `[Container] Command completed: ${command}, Success: ${success}, Exit code: ${exitCode}`
@@ -135,6 +135,10 @@ export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
       return parseInt(proxyMatch[1]);
     }
 
+    if (url.port) {
+      return parseInt(url.port);
+    }
+
     // All other requests go to control plane on port 3000
     // This includes /api/* endpoints and any other control requests
     return 3000;
@@ -260,6 +264,11 @@ export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
     return session.readFile(path, options);
   }
 
+  async readFileStream(path: string): Promise<ReadableStream<Uint8Array>> {
+    const session = await this.ensureDefaultSession();
+    return session.readFileStream(path);
+  }
+
   async listFiles(
     path: string,
     options: {
@@ -674,7 +683,11 @@ export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
       readFile: async (path: string, options?: { encoding?: string }) => {
         return await this.client.readFile(path, options?.encoding, sessionId);
       },
-      
+
+      readFileStream: async (path: string) => {
+        return await this.client.readFileStream(path, sessionId);
+      },
+
       mkdir: async (path: string, options?: { recursive?: boolean }) => {
         return await this.client.mkdir(path, options?.recursive, sessionId);
       },

package/src/types.ts

@@ -215,6 +215,54 @@ export interface StreamOptions extends BaseExecOptions {
   signal?: AbortSignal;
 }
 
+// File Streaming Types
+
+/**
+ * SSE events for file streaming
+ */
+export type FileStreamEvent =
+  | {
+      type: 'metadata';
+      mimeType: string;
+      size: number;
+      isBinary: boolean;
+      encoding: 'utf-8' | 'base64';
+    }
+  | {
+      type: 'chunk';
+      data: string; // base64 for binary, UTF-8 for text
+    }
+  | {
+      type: 'complete';
+      bytesRead: number;
+    }
+  | {
+      type: 'error';
+      error: string;
+    };
+
+/**
+ * File metadata from streaming
+ */
+export interface FileMetadata {
+  mimeType: string;
+  size: number;
+  isBinary: boolean;
+  encoding: 'utf-8' | 'base64';
+}
+
+/**
+ * File stream chunk - either string (text) or Uint8Array (binary, auto-decoded)
+ */
+export type FileChunk = string | Uint8Array;
+
+/**
+ * AsyncIterable of file chunks with metadata
+ */
+export interface FileStream extends AsyncIterable<FileChunk> {
+  metadata?: FileMetadata;
+}
+
 // Error Types
 
 export class SandboxError extends Error {
@@ -359,6 +407,7 @@ export interface ISandbox {
   renameFile(oldPath: string, newPath: string): Promise<RenameFileResponse>;
   moveFile(sourcePath: string, destinationPath: string): Promise<MoveFileResponse>;
   readFile(path: string, options?: { encoding?: string }): Promise<ReadFileResponse>;
+  readFileStream(path: string): Promise<ReadableStream<Uint8Array>>;
   listFiles(path: string, options?: { recursive?: boolean; includeHidden?: boolean }): Promise<ListFilesResponse>;
 
   // Port management
@@ -434,6 +483,26 @@ export interface ReadFileResponse {
   path: string;
   content: string;
   timestamp: string;
+
+  /**
+   * Encoding used for content (utf-8 for text, base64 for binary)
+   */
+  encoding?: 'utf-8' | 'base64';
+
+  /**
+   * Whether the file is detected as binary
+   */
+  isBinary?: boolean;
+
+  /**
+   * MIME type of the file (e.g., 'image/png', 'text/plain')
+   */
+  mimeType?: string;
+
+  /**
+   * File size in bytes
+   */
+  size?: number;
 }
 
 export interface DeleteFileResponse {