@cloudflare/sandbox 0.0.0-d81d2a5 → 0.0.0-d951819

package/src/types.ts

@@ -1,11 +1,6 @@
 // Core Types
 
 export interface BaseExecOptions {
-  /**
-   * Session ID for grouping related commands
-   */
-  sessionId?: string;
-
   /**
    * Maximum execution time in milliseconds
    */
@@ -90,11 +85,6 @@ export interface ExecResult {
    * ISO timestamp when command started
    */
   timestamp: string;
-
-  /**
-   * Session ID if provided
-   */
-  sessionId?: string;
 }
 
 // Background Process Types
@@ -177,11 +167,6 @@ export interface Process {
    */
   readonly exitCode?: number;
 
-  /**
-   * Session ID if provided
-   */
-  readonly sessionId?: string;
-
   /**
    * Kill the process
    */
@@ -208,7 +193,6 @@ export interface ExecEvent {
   exitCode?: number;
   result?: ExecResult;
   error?: string; // Changed to string for serialization
-  sessionId?: string;
 }
 
 export interface LogEvent {
@@ -216,7 +200,6 @@ export interface LogEvent {
   timestamp: string;
   data: string;
   processId: string;
-  sessionId?: string;
   exitCode?: number; // For 'exit' events
 }
 
@@ -232,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 {
@@ -272,10 +303,8 @@ export interface ProcessRecord {
   startTime: Date;
   endTime?: Date;
   exitCode?: number;
-  sessionId?: string;
 
   // Internal fields
-  childProcess?: any;  // Node.js ChildProcess
   stdout: string;      // Accumulated output (ephemeral)
   stderr: string;      // Accumulated output (ephemeral)
 
@@ -290,7 +319,6 @@ export interface StartProcessRequest {
   command: string;
   options?: {
     processId?: string;
-    sessionId?: string;
     timeout?: number;
     env?: Record<string, string>;
     cwd?: string;
@@ -304,9 +332,11 @@ export interface StartProcessResponse {
     id: string;
     pid?: number;
     command: string;
-      status: ProcessStatus;
+    status: ProcessStatus;
     startTime: string;
-    sessionId?: string;
+    endTime?: string | null;
+    exitCode?: number | null;
+    sessionId: string;
   };
 }
 
@@ -319,7 +349,6 @@ export interface ListProcessesResponse {
     startTime: string;
     endTime?: string;
     exitCode?: number;
-    sessionId?: string;
   }>;
 }
 
@@ -332,7 +361,6 @@ export interface GetProcessResponse {
     startTime: string;
     endTime?: string;
     exitCode?: number;
-    sessionId?: string;
   } | null;
 }
 
@@ -371,6 +399,26 @@ export interface ISandbox {
   cleanupCompletedProcesses(): Promise<number>;
   getProcessLogs(id: string): Promise<{ stdout: string; stderr: string }>;
 
+  // File operations
+  gitCheckout(repoUrl: string, options: { branch?: string; targetDir?: string }): Promise<GitCheckoutResponse>;
+  mkdir(path: string, options?: { recursive?: boolean }): Promise<MkdirResponse>;
+  writeFile(path: string, content: string, options?: { encoding?: string }): Promise<WriteFileResponse>;
+  deleteFile(path: string): Promise<DeleteFileResponse>;
+  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
+  exposePort(port: number, options: { name?: string; hostname: string }): Promise<{ url: string; port: number; name?: string }>;
+  unexposePort(port: number): Promise<void>;
+  getExposedPorts(hostname: string): Promise<Array<{ url: string; port: number; name?: string; exposedAt: string }>>;
+
+  // Environment management
+  setEnvVars(envVars: Record<string, string>): Promise<void>;
+  setSandboxName(name: string): Promise<void>;
+
   // Code Interpreter API
   createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
   runCode(code: string, options?: RunCodeOptions): Promise<ExecutionResult>;
@@ -379,6 +427,128 @@ export interface ISandbox {
   deleteCodeContext(contextId: string): Promise<void>;
 }
 
+// Execution session returned by createSession()
+// Sessions are full-featured sandbox objects with scoped execution context
+// Inherits all ISandbox methods except createSession (sessions can't create sub-sessions),
+// and setSandboxName (sessions inherit sandbox name).
+export interface ExecutionSession extends Omit<ISandbox, 'createSession' | 'setSandboxName'> {
+  /**
+   * Session ID
+   */
+  id: string;
+}
+
+// API Response Types
+
+export interface ExecuteResponse {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  command: string;
+  timestamp: string;
+}
+
+export interface GitCheckoutResponse {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  repoUrl: string;
+  branch: string;
+  targetDir: string;
+  timestamp: string;
+}
+
+export interface MkdirResponse {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  path: string;
+  recursive: boolean;
+  timestamp: string;
+}
+
+export interface WriteFileResponse {
+  success: boolean;
+  exitCode: number;
+  path: string;
+  timestamp: string;
+}
+
+export interface ReadFileResponse {
+  success: boolean;
+  exitCode: number;
+  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 {
+  success: boolean;
+  exitCode: number;
+  path: string;
+  timestamp: string;
+}
+
+export interface RenameFileResponse {
+  success: boolean;
+  exitCode: number;
+  oldPath: string;
+  newPath: string;
+  timestamp: string;
+}
+
+export interface MoveFileResponse {
+  success: boolean;
+  exitCode: number;
+  sourcePath: string;
+  destinationPath: string;
+  timestamp: string;
+}
+
+export interface ListFilesResponse {
+  success: boolean;
+  exitCode: number;
+  path: string;
+  files: Array<{
+    name: string;
+    absolutePath: string;
+    relativePath: string;
+    type: 'file' | 'directory' | 'symlink' | 'other';
+    size: number;
+    modifiedAt: string;
+    mode: string;
+    permissions: {
+      readable: boolean;
+      writable: boolean;
+      executable: boolean;
+    };
+  }>;
+  timestamp: string;
+}
+
 // Type Guards
 
 export function isExecResult(value: any): value is ExecResult {

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();
-  }
-}
-