@cloudflare/sandbox 0.1.4 → 0.2.1

package/container_src/index.ts

@@ -25,6 +25,7 @@ import {
   handleStartProcessRequest,
   handleStreamProcessLogsRequest,
 } from "./handler/process";
+import { type CreateContextRequest, JupyterServer } from "./jupyter-server";
 import type { ProcessRecord, SessionData } from "./types";
 
 // In-memory session storage (in production, you'd want to use a proper database)
@@ -55,8 +56,28 @@ function cleanupOldSessions() {
 // Run cleanup every 10 minutes
 setInterval(cleanupOldSessions, 10 * 60 * 1000);
 
+// Initialize Jupyter server
+const jupyterServer = new JupyterServer();
+let jupyterInitialized = false;
+
+// Initialize Jupyter immediately since startup.sh ensures it's ready
+(async () => {
+  try {
+    await jupyterServer.initialize();
+    jupyterInitialized = true;
+    console.log("[Container] Jupyter integration initialized successfully");
+  } catch (error) {
+    console.error("[Container] Failed to initialize Jupyter:", error);
+    // Log more details to help debug
+    if (error instanceof Error) {
+      console.error("[Container] Error details:", error.message);
+      console.error("[Container] Stack trace:", error.stack);
+    }
+  }
+})();
+
 const server = serve({
-  fetch(req: Request) {
+  async fetch(req: Request) {
     const url = new URL(req.url);
     const pathname = url.pathname;
 
@@ -159,6 +180,7 @@ const server = serve({
               JSON.stringify({
                 message: "pong",
                 timestamp: new Date().toISOString(),
+                jupyter: jupyterInitialized ? "ready" : "not ready",
               }),
               {
                 headers: {
@@ -280,7 +302,151 @@ const server = serve({
           }
           break;
 
+        // Code interpreter endpoints
+        case "/api/contexts":
+          if (req.method === "POST") {
+            if (!jupyterInitialized) {
+              return new Response(
+                JSON.stringify({
+                  error: "Jupyter server is not ready. Please try again in a moment."
+                }),
+                {
+                  status: 503,
+                  headers: {
+                    "Content-Type": "application/json",
+                    ...corsHeaders,
+                  },
+                }
+              );
+            }
+            try {
+              const body = await req.json() as CreateContextRequest;
+              const context = await jupyterServer.createContext(body);
+              return new Response(
+                JSON.stringify({
+                  id: context.id,
+                  language: context.language,
+                  cwd: context.cwd,
+                  createdAt: context.createdAt,
+                  lastUsed: context.lastUsed
+                }),
+                {
+                  headers: {
+                    "Content-Type": "application/json",
+                    ...corsHeaders,
+                  },
+                }
+              );
+            } catch (error) {
+              console.error("[Container] Error creating context:", error);
+              return new Response(
+                JSON.stringify({
+                  error: error instanceof Error ? error.message : "Failed to create context"
+                }),
+                {
+                  status: 500,
+                  headers: {
+                    "Content-Type": "application/json",
+                    ...corsHeaders,
+                  },
+                }
+              );
+            }
+          } else if (req.method === "GET") {
+            if (!jupyterInitialized) {
+              return new Response(
+                JSON.stringify({ contexts: [] }),
+                {
+                  headers: {
+                    "Content-Type": "application/json",
+                    ...corsHeaders,
+                  },
+                }
+              );
+            }
+            const contexts = await jupyterServer.listContexts();
+            return new Response(
+              JSON.stringify({ contexts }),
+              {
+                headers: {
+                  "Content-Type": "application/json",
+                  ...corsHeaders,
+                },
+              }
+            );
+          }
+          break;
+
+        case "/api/execute/code":
+          if (req.method === "POST") {
+            if (!jupyterInitialized) {
+              return new Response(
+                JSON.stringify({
+                  error: "Jupyter server is not ready. Please try again in a moment."
+                }),
+                {
+                  status: 503,
+                  headers: {
+                    "Content-Type": "application/json",
+                    ...corsHeaders,
+                  },
+                }
+              );
+            }
+            try {
+              const body = await req.json() as { context_id: string; code: string; language?: string };
+              return await jupyterServer.executeCode(body.context_id, body.code, body.language);
+            } catch (error) {
+              console.error("[Container] Error executing code:", error);
+              return new Response(
+                JSON.stringify({
+                  error: error instanceof Error ? error.message : "Failed to execute code"
+                }),
+                {
+                  status: 500,
+                  headers: {
+                    "Content-Type": "application/json",
+                    ...corsHeaders,
+                  },
+                }
+              );
+            }
+          }
+          break;
+
         default:
+          // Handle dynamic routes for contexts
+          if (pathname.startsWith("/api/contexts/") && pathname.split('/').length === 4) {
+            const contextId = pathname.split('/')[3];
+            if (req.method === "DELETE") {
+              try {
+                await jupyterServer.deleteContext(contextId);
+                return new Response(
+                  JSON.stringify({ success: true }),
+                  {
+                    headers: {
+                      "Content-Type": "application/json",
+                      ...corsHeaders,
+                    },
+                  }
+                );
+              } catch (error) {
+                return new Response(
+                  JSON.stringify({
+                    error: error instanceof Error ? error.message : "Failed to delete context"
+                  }),
+                  {
+                    status: error instanceof Error && error.message.includes("not found") ? 404 : 500,
+                    headers: {
+                      "Content-Type": "application/json",
+                      ...corsHeaders,
+                    },
+                  }
+                );
+              }
+            }
+          }
+          
           // Handle dynamic routes for individual processes
           if (pathname.startsWith("/api/process/")) {
             const segments = pathname.split('/');
@@ -357,5 +523,9 @@ console.log(`   GET  /api/process/{id}/logs - Get process logs`);
 console.log(`   GET  /api/process/{id}/stream - Stream process logs (SSE)`);
 console.log(`   DELETE /api/process/kill-all - Kill all processes`);
 console.log(`   GET  /proxy/{port}/* - Proxy requests to exposed ports`);
+console.log(`   POST /api/contexts - Create a code execution context`);
+console.log(`   GET  /api/contexts - List all contexts`);
+console.log(`   DELETE /api/contexts/{id} - Delete a context`);
+console.log(`   POST /api/execute/code - Execute code in a context (streaming)`);
 console.log(`   GET  /api/ping - Health check`);
 console.log(`   GET  /api/commands - List available commands`);

package/container_src/jupyter-server.ts

@@ -0,0 +1,336 @@
+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();
+  }
+}
+