@cloudflare/sandbox 0.0.0-c87db11 → 0.0.0-cdb8197

package/container_src/handler/session.ts

@@ -0,0 +1,92 @@
+import type { SessionManager } from "../isolation";
+import type { CreateSessionRequest } from "../types";
+
+export async function handleCreateSession(
+  req: Request,
+  corsHeaders: Record<string, string>,
+  sessionManager: SessionManager 
+) {
+  try {
+    const body = (await req.json()) as CreateSessionRequest;
+    const { id, env, cwd, isolation } = body;
+
+    if (!id) {
+      return new Response(
+        JSON.stringify({ error: "Session ID is required" }),
+        {
+          status: 400,
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+        }
+      );
+    }
+
+    await sessionManager.createSession({
+      id,
+      env: env || {},
+      cwd: cwd || "/workspace",
+      isolation: isolation !== false,
+    });
+
+    console.log(`[Container] Session '${id}' created successfully`);
+    console.log(
+      `[Container] Available sessions now: ${sessionManager
+        .listSessions()
+        .join(", ")}`
+    );
+
+    return new Response(
+      JSON.stringify({
+        success: true,
+        id,
+        message: `Session '${id}' created with${
+          isolation !== false ? "" : "out"
+        } isolation`,
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  } catch (error) {
+    console.error("[Container] Failed to create session:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to create session",
+        message:
+          error instanceof Error ? error.message : String(error),
+      }),
+      {
+        status: 500,
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  }
+}
+
+export function handleListSessions(
+  corsHeaders: Record<string, string>,
+  sessionManager: SessionManager
+) {
+  const sessionList = sessionManager.listSessions();
+  return new Response(
+    JSON.stringify({
+      count: sessionList.length,
+      sessions: sessionList,
+      timestamp: new Date().toISOString(),
+    }),
+    {
+      headers: {
+        "Content-Type": "application/json",
+        ...corsHeaders,
+      },
+    }
+  );
+}

package/container_src/index.ts

@@ -1,4 +1,3 @@
-import { randomBytes } from "node:crypto";
 import { serve } from "bun";
 import {
   handleExecuteRequest,
@@ -6,9 +5,11 @@ import {
 } from "./handler/exec";
 import {
   handleDeleteFileRequest,
+  handleListFilesRequest,
   handleMkdirRequest,
   handleMoveFileRequest,
   handleReadFileRequest,
+  handleReadFileStreamRequest,
   handleRenameFileRequest,
   handleWriteFileRequest,
 } from "./handler/file";
@@ -28,62 +29,65 @@ import {
   handleStartProcessRequest,
   handleStreamProcessLogsRequest,
 } from "./handler/process";
-import type { CreateContextRequest } from "./jupyter-server";
-import { JupyterNotReadyError, JupyterService } from "./jupyter-service";
-import type { ProcessRecord, SessionData } from "./types";
-
-// In-memory session storage (in production, you'd want to use a proper database)
-const sessions = new Map<string, SessionData>();
+import { handleCreateSession, handleListSessions } from "./handler/session";
+import type { CreateContextRequest } from "./interpreter-service";
+import {
+  InterpreterNotReadyError,
+  InterpreterService,
+} from "./interpreter-service";
+import { hasNamespaceSupport, SessionManager } from "./isolation";
 
 // In-memory storage for exposed ports
 const exposedPorts = new Map<number, { name?: string; exposedAt: Date }>();
 
-// In-memory process storage - cleared on container restart
-const processes = new Map<string, ProcessRecord>();
-
-// Generate a unique session ID using cryptographically secure randomness
-function generateSessionId(): string {
-  return `session_${Date.now()}_${randomBytes(6).toString("hex")}`;
-}
-
-// Clean up old sessions (older than 1 hour)
-function cleanupOldSessions() {
-  const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
-  for (const [sessionId, session] of sessions.entries()) {
-    if (session.createdAt < oneHourAgo && !session.activeProcess) {
-      sessions.delete(sessionId);
-      console.log(`[Server] Cleaned up old session: ${sessionId}`);
-    }
-  }
-}
+// Check isolation capabilities on startup
+const isolationAvailable = hasNamespaceSupport();
+console.log(
+  `[Container] Process isolation: ${
+    isolationAvailable
+      ? "ENABLED (production mode)"
+      : "DISABLED (development mode)"
+  }`
+);
 
-// Run cleanup every 10 minutes
-setInterval(cleanupOldSessions, 10 * 60 * 1000);
+// Session manager for secure execution with isolation
+const sessionManager = new SessionManager();
 
-// Initialize Jupyter service with graceful degradation
-const jupyterService = new JupyterService();
+// Graceful shutdown handler
+const SHUTDOWN_GRACE_PERIOD_MS = 5000; // Grace period for cleanup (5 seconds for proper async cleanup)
 
-// Start Jupyter initialization in background (non-blocking)
-console.log("[Container] Starting Jupyter initialization in background...");
-console.log(
-  "[Container] API endpoints are available immediately. Jupyter-dependent features will be available shortly."
-);
+process.on("SIGTERM", async () => {
+  console.log("[Container] SIGTERM received, cleaning up sessions...");
+  await sessionManager.destroyAll();
+  setTimeout(() => {
+    process.exit(0);
+  }, SHUTDOWN_GRACE_PERIOD_MS);
+});
 
-jupyterService
-  .initialize()
-  .then(() => {
-    console.log(
-      "[Container] Jupyter fully initialized - all features available"
-    );
-  })
-  .catch((error) => {
-    console.error("[Container] Jupyter initialization failed:", error.message);
-    console.error(
-      "[Container] The API will continue in degraded mode without code execution capabilities"
-    );
-  });
+process.on("SIGINT", async () => {
+  console.log("[Container] SIGINT received, cleaning up sessions...");
+  await sessionManager.destroyAll();
+  setTimeout(() => {
+    process.exit(0);
+  }, SHUTDOWN_GRACE_PERIOD_MS);
+});
+
+// Cleanup on uncaught exceptions (log but still exit)
+process.on("uncaughtException", async (error) => {
+  console.error("[Container] Uncaught exception:", error);
+  await sessionManager.destroyAll();
+  process.exit(1);
+});
+
+// Initialize interpreter service
+const interpreterService = new InterpreterService();
+
+// No initialization needed - service is ready immediately!
+console.log("[Container] Interpreter service ready - no cold start!");
+console.log("[Container] All API endpoints available immediately");
 
 const server = serve({
+  idleTimeout: 255,
   async fetch(req: Request) {
     const url = new URL(req.url);
     const pathname = url.pathname;
@@ -117,115 +121,42 @@ const server = serve({
 
         case "/api/session/create":
           if (req.method === "POST") {
-            const sessionId = generateSessionId();
-            const sessionData: SessionData = {
-              activeProcess: null,
-              createdAt: new Date(),
-              sessionId,
-            };
-            sessions.set(sessionId, sessionData);
-
-            console.log(`[Server] Created new session: ${sessionId}`);
-
-            return new Response(
-              JSON.stringify({
-                message: "Session created successfully",
-                sessionId,
-                timestamp: new Date().toISOString(),
-              }),
-              {
-                headers: {
-                  "Content-Type": "application/json",
-                  ...corsHeaders,
-                },
-              }
-            );
+            return handleCreateSession(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/session/list":
           if (req.method === "GET") {
-            const sessionList = Array.from(sessions.values()).map(
-              (session) => ({
-                createdAt: session.createdAt.toISOString(),
-                hasActiveProcess: !!session.activeProcess,
-                sessionId: session.sessionId,
-              })
-            );
-
-            return new Response(
-              JSON.stringify({
-                count: sessionList.length,
-                sessions: sessionList,
-                timestamp: new Date().toISOString(),
-              }),
-              {
-                headers: {
-                  "Content-Type": "application/json",
-                  ...corsHeaders,
-                },
-              }
-            );
+            return handleListSessions(corsHeaders, sessionManager);
           }
           break;
 
         case "/api/execute":
           if (req.method === "POST") {
-            return handleExecuteRequest(sessions, req, corsHeaders);
+            return handleExecuteRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/execute/stream":
           if (req.method === "POST") {
-            return handleStreamingExecuteRequest(sessions, req, corsHeaders);
+            return handleStreamingExecuteRequest(
+              req,
+              sessionManager,
+              corsHeaders
+            );
           }
           break;
 
         case "/api/ping":
           if (req.method === "GET") {
-            const health = await jupyterService.getHealthStatus();
+            const health = await interpreterService.getHealthStatus();
             return new Response(
               JSON.stringify({
                 message: "pong",
                 timestamp: new Date().toISOString(),
-                jupyter: health.ready
-                  ? "ready"
-                  : health.initializing
-                  ? "initializing"
-                  : "not ready",
-                jupyterHealth: health,
-              }),
-              {
-                headers: {
-                  "Content-Type": "application/json",
-                  ...corsHeaders,
-                },
-              }
-            );
-          }
-          break;
-
-        case "/api/commands":
-          if (req.method === "GET") {
-            return new Response(
-              JSON.stringify({
-                availableCommands: [
-                  "ls",
-                  "pwd",
-                  "echo",
-                  "cat",
-                  "grep",
-                  "find",
-                  "whoami",
-                  "date",
-                  "uptime",
-                  "ps",
-                  "top",
-                  "df",
-                  "du",
-                  "free",
-                ],
-                timestamp: new Date().toISOString(),
+                system: "interpreter (70x faster)",
+                status: health.ready ? "ready" : "initializing",
+                progress: health.progress,
               }),
               {
                 headers: {
@@ -239,43 +170,55 @@ const server = serve({
 
         case "/api/git/checkout":
           if (req.method === "POST") {
-            return handleGitCheckoutRequest(sessions, req, corsHeaders);
+            return handleGitCheckoutRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/mkdir":
           if (req.method === "POST") {
-            return handleMkdirRequest(sessions, req, corsHeaders);
+            return handleMkdirRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/write":
           if (req.method === "POST") {
-            return handleWriteFileRequest(req, corsHeaders);
+            return handleWriteFileRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/read":
           if (req.method === "POST") {
-            return handleReadFileRequest(req, corsHeaders);
+            return handleReadFileRequest(req, corsHeaders, sessionManager);
+          }
+          break;
+
+        case "/api/read/stream":
+          if (req.method === "POST") {
+            return handleReadFileStreamRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/delete":
           if (req.method === "POST") {
-            return handleDeleteFileRequest(req, corsHeaders);
+            return handleDeleteFileRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/rename":
           if (req.method === "POST") {
-            return handleRenameFileRequest(req, corsHeaders);
+            return handleRenameFileRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/move":
           if (req.method === "POST") {
-            return handleMoveFileRequest(req, corsHeaders);
+            return handleMoveFileRequest(req, corsHeaders, sessionManager);
+          }
+          break;
+
+        case "/api/list-files":
+          if (req.method === "POST") {
+            return handleListFilesRequest(req, corsHeaders, sessionManager);
           }
           break;
 
@@ -299,28 +242,31 @@ const server = serve({
 
         case "/api/process/start":
           if (req.method === "POST") {
-            return handleStartProcessRequest(processes, req, corsHeaders);
+            return handleStartProcessRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/process/list":
           if (req.method === "GET") {
-            return handleListProcessesRequest(processes, req, corsHeaders);
+            return handleListProcessesRequest(req, corsHeaders, sessionManager);
           }
           break;
 
         case "/api/process/kill-all":
           if (req.method === "DELETE") {
-            return handleKillAllProcessesRequest(processes, req, corsHeaders);
+            return handleKillAllProcessesRequest(
+              req,
+              corsHeaders,
+              sessionManager
+            );
           }
           break;
 
-        // Code interpreter endpoints
         case "/api/contexts":
           if (req.method === "POST") {
             try {
               const body = (await req.json()) as CreateContextRequest;
-              const context = await jupyterService.createContext(body);
+              const context = await interpreterService.createContext(body);
               return new Response(
                 JSON.stringify({
                   id: context.id,
@@ -337,10 +283,9 @@ const server = serve({
                 }
               );
             } catch (error) {
-              if (error instanceof JupyterNotReadyError) {
-                // This happens when request times out waiting for Jupyter
+              if (error instanceof InterpreterNotReadyError) {
                 console.log(
-                  `[Container] Request timed out waiting for Jupyter (${error.progress}% complete)`
+                  `[Container] Request timed out waiting for interpreter (${error.progress}% complete)`
                 );
                 return new Response(
                   JSON.stringify({
@@ -405,7 +350,7 @@ const server = serve({
               );
             }
           } else if (req.method === "GET") {
-            const contexts = await jupyterService.listContexts();
+            const contexts = await interpreterService.listContexts();
             return new Response(JSON.stringify({ contexts }), {
               headers: {
                 "Content-Type": "application/json",
@@ -423,7 +368,7 @@ const server = serve({
                 code: string;
                 language?: string;
               };
-              return await jupyterService.executeCode(
+              return await interpreterService.executeCode(
                 body.context_id,
                 body.code,
                 body.language
@@ -462,12 +407,12 @@ const server = serve({
                 error.message.includes("initializing")
               ) {
                 console.log(
-                  "[Container] Code execution deferred - Jupyter still initializing"
+                  "[Container] Code execution deferred - service still initializing"
                 );
               } else {
                 console.error("[Container] Error executing code:", error);
               }
-              // Error response is already handled by jupyterService.executeCode for not ready state
+              // Error response is already handled by service.executeCode for not ready state
               return new Response(
                 JSON.stringify({
                   error:
@@ -496,7 +441,7 @@ const server = serve({
             const contextId = pathname.split("/")[3];
             if (req.method === "DELETE") {
               try {
-                await jupyterService.deleteContext(contextId);
+                await interpreterService.deleteContext(contextId);
                 return new Response(JSON.stringify({ success: true }), {
                   headers: {
                     "Content-Type": "application/json",
@@ -504,9 +449,9 @@ const server = serve({
                   },
                 });
               } catch (error) {
-                if (error instanceof JupyterNotReadyError) {
+                if (error instanceof InterpreterNotReadyError) {
                   console.log(
-                    `[Container] Request timed out waiting for Jupyter (${error.progress}% complete)`
+                    `[Container] Request timed out waiting for interpreter (${error.progress}% complete)`
                   );
                   return new Response(
                     JSON.stringify({
@@ -556,31 +501,31 @@ const server = serve({
 
               if (!action && req.method === "GET") {
                 return handleGetProcessRequest(
-                  processes,
                   req,
                   corsHeaders,
-                  processId
+                  processId,
+                  sessionManager
                 );
               } else if (!action && req.method === "DELETE") {
                 return handleKillProcessRequest(
-                  processes,
                   req,
                   corsHeaders,
-                  processId
+                  processId,
+                  sessionManager
                 );
               } else if (action === "logs" && req.method === "GET") {
                 return handleGetProcessLogsRequest(
-                  processes,
                   req,
                   corsHeaders,
-                  processId
+                  processId,
+                  sessionManager
                 );
               } else if (action === "stream" && req.method === "GET") {
                 return handleStreamProcessLogsRequest(
-                  processes,
                   req,
                   corsHeaders,
-                  processId
+                  processId,
+                  sessionManager
                 );
               }
             }
@@ -632,6 +577,7 @@ console.log(`   POST /api/git/checkout - Checkout a git repository`);
 console.log(`   POST /api/mkdir - Create a directory`);
 console.log(`   POST /api/write - Write a file`);
 console.log(`   POST /api/read - Read a file`);
+console.log(`   POST /api/read/stream - Stream a file (SSE)`);
 console.log(`   POST /api/delete - Delete a file`);
 console.log(`   POST /api/rename - Rename a file`);
 console.log(`   POST /api/move - Move a file`);
@@ -653,4 +599,3 @@ 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`);