@cloudflare/sandbox 0.0.0-fd5ec7f → 0.0.0-feafd32

package/container_src/handler/exec.ts

@@ -1,337 +1,184 @@
-import { type SpawnOptions, spawn } from "node:child_process";
-import type { ExecuteOptions, ExecuteRequest, SessionData } from "../types";
+import type { SessionManager } from "../isolation";
+import type { SessionExecRequest } from "../types";
 
-function executeCommand(
-  sessions: Map<string, SessionData>,
-  command: string,
-  options: ExecuteOptions,
-): Promise<{
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}> {
-  return new Promise((resolve, reject) => {
-    const spawnOptions: SpawnOptions = {
-      shell: true,
-      stdio: ["pipe", "pipe", "pipe"] as const,
-      detached: options.background || false,
-      cwd: options.cwd,
-      env: options.env ? { ...process.env, ...options.env } : process.env
-    };
-
-    const child = spawn(command, spawnOptions);
-
-    // Store the process reference for cleanup if sessionId is provided
-    if (options.sessionId && sessions.has(options.sessionId)) {
-      const session = sessions.get(options.sessionId)!;
-      session.activeProcess = child;
-    }
-
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    if (options.background) {
-      // For background processes, unref and return quickly
-      child.unref();
-
-      // Collect initial output for 100ms then return
-      setTimeout(() => {
-        resolve({
-          exitCode: 0, // Process is still running
-          stderr,
-          stdout,
-          success: true,
-        });
-      }, 100);
-
-      // Still handle errors
-      child.on("error", (error) => {
-        console.error(`[Server] Background process error: ${command}`, error);
-        // Don't reject since we might have already resolved
-      });
-    } else {
-      // Normal synchronous execution
-      child.on("close", (code) => {
-        // Clear the active process reference
-        if (options.sessionId && sessions.has(options.sessionId)) {
-          const session = sessions.get(options.sessionId)!;
-          session.activeProcess = null;
-        }
-
-        console.log(`[Server] Command completed: ${command}, Exit code: ${code}`);
+export async function handleExecuteRequest(
+  req: Request,
+  corsHeaders: Record<string, string>,
+  sessionManager: SessionManager
+) {
+  try {
+    const body = (await req.json()) as SessionExecRequest;
+    const { id, command } = body;
 
-        resolve({
-          exitCode: code || 0,
-          stderr,
-          stdout,
-          success: code === 0,
-        });
-      });
+    console.log(
+      `[Container] Session exec request for '${id}': ${command}`
+    );
 
-      child.on("error", (error) => {
-        // Clear the active process reference
-        if (options.sessionId && sessions.has(options.sessionId)) {
-          const session = sessions.get(options.sessionId)!;
-          session.activeProcess = null;
+    if (!id || !command) {
+      return new Response(
+        JSON.stringify({
+          error: "Session ID and command are required",
+        }),
+        {
+          status: 400,
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
         }
-
-        reject(error);
-      });
+      );
     }
-  });
-}
 
-export async function handleExecuteRequest(
-  sessions: Map<string, SessionData>,
-  req: Request,
-  corsHeaders: Record<string, string>
-): Promise<Response> {
-  try {
-    const body = (await req.json()) as ExecuteRequest;
-    const { command, sessionId, background, cwd, env } = body;
+    const session = sessionManager.getSession(id);
+    if (!session) {
+      console.error(`[Container] Session '${id}' not found!`);
+      const availableSessions = sessionManager.listSessions();
+      console.log(
+        `[Container] Available sessions: ${
+          availableSessions.join(", ") || "none"
+        }`
+      );
 
-    if (!command || typeof command !== "string") {
       return new Response(
         JSON.stringify({
-          error: "Command is required and must be a string",
+          error: `Session '${id}' not found`,
+          availableSessions,
         }),
         {
+          status: 404,
           headers: {
             "Content-Type": "application/json",
             ...corsHeaders,
           },
-          status: 400,
         }
       );
     }
 
-    console.log(`[Server] Executing command: ${command}`);
-
-    const result = await executeCommand(sessions, command, { sessionId, background, cwd, env });
+    const result = await session.exec(command);
 
-    return new Response(
-      JSON.stringify({
-        command,
-        exitCode: result.exitCode,
-        stderr: result.stderr,
-        stdout: result.stdout,
-        success: result.success,
-        timestamp: new Date().toISOString(),
-      }),
-      {
-        headers: {
-          "Content-Type": "application/json",
-          ...corsHeaders,
-        },
-      }
-    );
+    return new Response(JSON.stringify(result), {
+      headers: { "Content-Type": "application/json", ...corsHeaders },
+    });
   } catch (error) {
-    console.error("[Server] Error in handleExecuteRequest:", error);
+    console.error("[Container] Session exec failed:", error);
     return new Response(
       JSON.stringify({
-        error: "Failed to execute command",
-        message: error instanceof Error ? error.message : "Unknown error",
+        error: "Command execution failed",
+        message:
+          error instanceof Error ? error.message : String(error),
       }),
       {
+        status: 500,
         headers: {
           "Content-Type": "application/json",
           ...corsHeaders,
         },
-        status: 500,
       }
     );
   }
 }
 
 export async function handleStreamingExecuteRequest(
-  sessions: Map<string, SessionData>,
   req: Request,
+  sessionManager: SessionManager,
   corsHeaders: Record<string, string>
-): Promise<Response> {
+) {
   try {
-    const body = (await req.json()) as ExecuteRequest;
-    const { command, sessionId, background } = body;
+    const body = (await req.json()) as SessionExecRequest;
+    const { id, command } = body;
+
+    console.log(
+      `[Container] Session streaming exec request for '${id}': ${command}`
+    );
 
-    if (!command || typeof command !== "string") {
+    if (!id || !command) {
       return new Response(
         JSON.stringify({
-          error: "Command is required and must be a string",
+          error: "Session ID and command are required",
         }),
         {
+          status: 400,
           headers: {
             "Content-Type": "application/json",
             ...corsHeaders,
           },
-          status: 400,
         }
       );
     }
 
-    console.log(
-      `[Server] Executing streaming command: ${command}`
-    );
-
-    const stream = new ReadableStream({
-      start(controller) {
-        const spawnOptions: SpawnOptions = {
-          shell: true,
-          stdio: ["pipe", "pipe", "pipe"] as const,
-          detached: background || false,
-        };
-
-        const child = spawn(command, spawnOptions);
+    const session = sessionManager.getSession(id);
+    if (!session) {
+      console.error(`[Container] Session '${id}' not found!`);
+      const availableSessions = sessionManager.listSessions();
 
-        // Store the process reference for cleanup if sessionId is provided
-        if (sessionId && sessions.has(sessionId)) {
-          const session = sessions.get(sessionId)!;
-          session.activeProcess = child;
-        }
-
-        // For background processes, unref to prevent blocking
-        if (background) {
-          child.unref();
+      return new Response(
+        JSON.stringify({
+          error: `Session '${id}' not found`,
+          availableSessions,
+        }),
+        {
+          status: 404,
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
         }
+      );
+    }
 
-        let stdout = "";
-        let stderr = "";
-
-        // Send command start event
-        controller.enqueue(
-          new TextEncoder().encode(
-            `data: ${JSON.stringify({
-              type: "start",
-              timestamp: new Date().toISOString(),
-              command,
-              background: background || false,
-            })}\n\n`
-          )
-        );
-
-        child.stdout?.on("data", (data) => {
-          const output = data.toString();
-          stdout += output;
-
-          // Send real-time output
-          controller.enqueue(
-            new TextEncoder().encode(
-              `data: ${JSON.stringify({
-                type: "stdout",
-                timestamp: new Date().toISOString(),
-                data: output,
-                command,
-              })}\n\n`
-            )
-          );
-        });
-
-        child.stderr?.on("data", (data) => {
-          const output = data.toString();
-          stderr += output;
-
-          // Send real-time error output
-          controller.enqueue(
-            new TextEncoder().encode(
-              `data: ${JSON.stringify({
-                type: "stderr",
-                timestamp: new Date().toISOString(),
-                data: output,
-                command,
-              })}\n\n`
-            )
-          );
-        });
-
-        child.on("close", (code) => {
-          // Clear the active process reference
-          if (sessionId && sessions.has(sessionId)) {
-            const session = sessions.get(sessionId)!;
-            session.activeProcess = null;
-          }
-
-          console.log(
-            `[Server] Command completed: ${command}, Exit code: ${code}`
-          );
-
-          // Send command completion event
-          controller.enqueue(
-            new TextEncoder().encode(
-              `data: ${JSON.stringify({
-                type: "complete",
-                timestamp: new Date().toISOString(),
-                command,
-                exitCode: code,
-                result: {
-                  success: code === 0,
-                  exitCode: code,
-                  stdout,
-                  stderr,
-                  command,
-                  timestamp: new Date().toISOString(),
-                },
-              })}\n\n`
-            )
-          );
-
-          // For non-background processes, close the stream
-          // For background processes with streaming, the stream stays open
-          if (!background) {
-            controller.close();
-          }
-        });
-
-        child.on("error", (error) => {
-          // Clear the active process reference
-          if (sessionId && sessions.has(sessionId)) {
-            const session = sessions.get(sessionId)!;
-            session.activeProcess = null;
+    // Create a streaming response using the actual streaming method
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          // Use the streaming generator method
+          for await (const event of session.execStream(command)) {
+            // Forward each event as SSE
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify(event)}\n\n`
+              )
+            );
           }
-
+          controller.close();
+        } catch (error) {
           controller.enqueue(
             new TextEncoder().encode(
               `data: ${JSON.stringify({
                 type: "error",
-                timestamp: new Date().toISOString(),
-                error: error.message,
-                command,
+                message:
+                  error instanceof Error
+                    ? error.message
+                    : String(error),
               })}\n\n`
             )
           );
-
           controller.close();
-        });
+        }
       },
     });
 
     return new Response(stream, {
       headers: {
+        "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
         Connection: "keep-alive",
-        "Content-Type": "text/event-stream",
         ...corsHeaders,
       },
     });
   } catch (error) {
-    console.error("[Server] Error in handleStreamingExecuteRequest:", error);
+    console.error("[Container] Session stream exec failed:", error);
     return new Response(
       JSON.stringify({
-        error: "Failed to execute streaming command",
-        message: error instanceof Error ? error.message : "Unknown error",
+        error: "Stream execution failed",
+        message:
+          error instanceof Error ? error.message : String(error),
       }),
       {
+        status: 500,
         headers: {
           "Content-Type": "application/json",
           ...corsHeaders,
         },
-        status: 500,
       }
     );
   }