@cloudflare/sandbox 0.0.0-60af265 → 0.0.0-6704961

package/container_src/index.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { type ChildProcess, type SpawnOptions, spawn } from "node:child_process";
 import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { serve } from "bun";
@@ -6,6 +6,8 @@ import { serve } from "bun";
 interface ExecuteRequest {
   command: string;
   args?: string[];
+  sessionId?: string;
+  background?: boolean;
 }
 
 interface GitCheckoutRequest {
@@ -51,15 +53,27 @@ interface MoveFileRequest {
   sessionId?: string;
 }
 
+interface ExposePortRequest {
+  port: number;
+  name?: string;
+}
+
+interface UnexposePortRequest {
+  port: number;
+}
+
 interface SessionData {
   sessionId: string;
-  activeProcess: any | null;
+  activeProcess: ChildProcess | null;
   createdAt: Date;
 }
 
 // In-memory session storage (in production, you'd want to use a proper database)
 const sessions = new Map<string, SessionData>();
 
+// In-memory storage for exposed ports
+const exposedPorts = new Map<number, { name?: string; exposedAt: Date }>();
+
 // Generate a unique session ID
 function generateSessionId(): string {
   return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
@@ -111,51 +125,6 @@ const server = serve({
             },
           });
 
-        case "/api/hello":
-          return new Response(
-            JSON.stringify({
-              message: "Hello from API!",
-              timestamp: new Date().toISOString(),
-            }),
-            {
-              headers: {
-                "Content-Type": "application/json",
-                ...corsHeaders,
-              },
-            }
-          );
-
-        case "/api/users":
-          if (req.method === "GET") {
-            return new Response(
-              JSON.stringify([
-                { id: 1, name: "Alice" },
-                { id: 2, name: "Bob" },
-                { id: 3, name: "Charlie" },
-              ]),
-              {
-                headers: {
-                  "Content-Type": "application/json",
-                  ...corsHeaders,
-                },
-              }
-            );
-          } else if (req.method === "POST") {
-            return new Response(
-              JSON.stringify({
-                message: "User created successfully",
-                method: "POST",
-              }),
-              {
-                headers: {
-                  "Content-Type": "application/json",
-                  ...corsHeaders,
-                },
-              }
-            );
-          }
-          break;
-
         case "/api/session/create":
           if (req.method === "POST") {
             const sessionId = generateSessionId();
@@ -355,7 +324,30 @@ const server = serve({
           }
           break;
 
+        case "/api/expose-port":
+          if (req.method === "POST") {
+            return handleExposePortRequest(req, corsHeaders);
+          }
+          break;
+
+        case "/api/unexpose-port":
+          if (req.method === "DELETE") {
+            return handleUnexposePortRequest(req, corsHeaders);
+          }
+          break;
+
+        case "/api/exposed-ports":
+          if (req.method === "GET") {
+            return handleGetExposedPortsRequest(req, corsHeaders);
+          }
+          break;
+
         default:
+          // Check if this is a proxy request for an exposed port
+          if (pathname.startsWith("/proxy/")) {
+            return handleProxyRequest(req, corsHeaders);
+          }
+
           console.log(`[Container] Route not found: ${pathname}`);
           return new Response("Not Found", {
             headers: corsHeaders,
@@ -381,15 +373,17 @@ const server = serve({
   },
   hostname: "0.0.0.0",
   port: 3000,
-} as any);
+  // We don't need this, but typescript complains
+  websocket: { async message() { } },
+});
 
 async function handleExecuteRequest(
   req: Request,
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as ExecuteRequest & { sessionId?: string };
-    const { command, args = [], sessionId } = body;
+    const body = (await req.json()) as ExecuteRequest;
+    const { command, args = [], sessionId, background } = body;
 
     if (!command || typeof command !== "string") {
       return new Response(
@@ -406,37 +400,9 @@ async function handleExecuteRequest(
       );
     }
 
-    // Basic safety check - prevent dangerous commands
-    const dangerousCommands = [
-      "rm",
-      "rmdir",
-      "del",
-      "format",
-      "shutdown",
-      "reboot",
-    ];
-    const lowerCommand = command.toLowerCase();
-
-    if (
-      dangerousCommands.some((dangerous) => lowerCommand.includes(dangerous))
-    ) {
-      return new Response(
-        JSON.stringify({
-          error: "Dangerous command not allowed",
-        }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...corsHeaders,
-          },
-          status: 400,
-        }
-      );
-    }
-
     console.log(`[Server] Executing command: ${command} ${args.join(" ")}`);
 
-    const result = await executeCommand(command, args, sessionId);
+    const result = await executeCommand(command, args, sessionId, background);
 
     return new Response(
       JSON.stringify({
@@ -478,8 +444,8 @@ async function handleStreamingExecuteRequest(
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as ExecuteRequest & { sessionId?: string };
-    const { command, args = [], sessionId } = body;
+    const body = (await req.json()) as ExecuteRequest;
+    const { command, args = [], sessionId, background } = body;
 
     if (!command || typeof command !== "string") {
       return new Response(
@@ -496,44 +462,19 @@ async function handleStreamingExecuteRequest(
       );
     }
 
-    // Basic safety check - prevent dangerous commands
-    const dangerousCommands = [
-      "rm",
-      "rmdir",
-      "del",
-      "format",
-      "shutdown",
-      "reboot",
-    ];
-    const lowerCommand = command.toLowerCase();
-
-    if (
-      dangerousCommands.some((dangerous) => lowerCommand.includes(dangerous))
-    ) {
-      return new Response(
-        JSON.stringify({
-          error: "Dangerous command not allowed",
-        }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...corsHeaders,
-          },
-          status: 400,
-        }
-      );
-    }
-
     console.log(
       `[Server] Executing streaming command: ${command} ${args.join(" ")}`
     );
 
     const stream = new ReadableStream({
       start(controller) {
-        const child = spawn(command, args, {
+        const spawnOptions: SpawnOptions = {
           shell: true,
-          stdio: ["pipe", "pipe", "pipe"],
-        });
+          stdio: ["pipe", "pipe", "pipe"] as const,
+          detached: background || false,
+        };
+
+        const child = spawn(command, args, spawnOptions);
 
         // Store the process reference for cleanup if sessionId is provided
         if (sessionId && sessions.has(sessionId)) {
@@ -541,6 +482,11 @@ async function handleStreamingExecuteRequest(
           session.activeProcess = child;
         }
 
+        // For background processes, unref to prevent blocking
+        if (background) {
+          child.unref();
+        }
+
         let stdout = "";
         let stderr = "";
 
@@ -552,6 +498,7 @@ async function handleStreamingExecuteRequest(
               command,
               timestamp: new Date().toISOString(),
               type: "command_start",
+              background: background || false,
             })}\n\n`
           )
         );
@@ -617,7 +564,11 @@ async function handleStreamingExecuteRequest(
             )
           );
 
-          controller.close();
+          // For non-background processes, close the stream
+          // For background processes with streaming, the stream stays open
+          if (!background) {
+            controller.close();
+          }
         });
 
         child.on("error", (error) => {
@@ -2507,7 +2458,8 @@ async function handleStreamingMoveFileRequest(
 function executeCommand(
   command: string,
   args: string[],
-  sessionId?: string
+  sessionId?: string,
+  background?: boolean
 ): Promise<{
   success: boolean;
   stdout: string;
@@ -2515,10 +2467,13 @@ function executeCommand(
   exitCode: number;
 }> {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
+    const spawnOptions: SpawnOptions = {
       shell: true,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
+      stdio: ["pipe", "pipe", "pipe"] as const,
+      detached: background || false,
+    };
+
+    const child = spawn(command, args, spawnOptions);
 
     // Store the process reference for cleanup if sessionId is provided
     if (sessionId && sessions.has(sessionId)) {
@@ -2537,32 +2492,54 @@ function executeCommand(
       stderr += data.toString();
     });
 
-    child.on("close", (code) => {
-      // Clear the active process reference
-      if (sessionId && sessions.has(sessionId)) {
-        const session = sessions.get(sessionId)!;
-        session.activeProcess = null;
-      }
+    if (background) {
+      // For background processes, unref and return quickly
+      child.unref();
 
-      console.log(`[Server] Command completed: ${command}, Exit code: ${code}`);
+      // Collect initial output for 100ms then return
+      setTimeout(() => {
+        resolve({
+          exitCode: 0, // Process is still running
+          stderr,
+          stdout,
+          success: true,
+        });
+      }, 100);
 
-      resolve({
-        exitCode: code || 0,
-        stderr,
-        stdout,
-        success: code === 0,
+      // 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 (sessionId && sessions.has(sessionId)) {
+          const session = sessions.get(sessionId)!;
+          session.activeProcess = null;
+        }
 
-    child.on("error", (error) => {
-      // 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}`);
 
-      reject(error);
-    });
+        resolve({
+          exitCode: code || 0,
+          stderr,
+          stdout,
+          success: code === 0,
+        });
+      });
+
+      child.on("error", (error) => {
+        // Clear the active process reference
+        if (sessionId && sessions.has(sessionId)) {
+          const session = sessions.get(sessionId)!;
+          session.activeProcess = null;
+        }
+
+        reject(error);
+      });
+    }
   });
 }
 
@@ -2880,6 +2857,315 @@ function executeMoveFile(
   });
 }
 
+async function handleExposePortRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as ExposePortRequest;
+    const { port, name } = body;
+
+    if (!port || typeof port !== "number") {
+      return new Response(
+        JSON.stringify({
+          error: "Port is required and must be a number",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Validate port range
+    if (port < 1 || port > 65535) {
+      return new Response(
+        JSON.stringify({
+          error: "Port must be between 1 and 65535",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Store the exposed port
+    exposedPorts.set(port, { name, exposedAt: new Date() });
+
+    console.log(`[Server] Exposed port: ${port}${name ? ` (${name})` : ""}`);
+
+    return new Response(
+      JSON.stringify({
+        port,
+        name,
+        exposedAt: new Date().toISOString(),
+        success: true,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  } catch (error) {
+    console.error("[Server] Error in handleExposePortRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to expose port",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
+async function handleUnexposePortRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as UnexposePortRequest;
+    const { port } = body;
+
+    if (!port || typeof port !== "number") {
+      return new Response(
+        JSON.stringify({
+          error: "Port is required and must be a number",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Check if port is exposed
+    if (!exposedPorts.has(port)) {
+      return new Response(
+        JSON.stringify({
+          error: "Port is not exposed",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 404,
+        }
+      );
+    }
+
+    // Remove the exposed port
+    exposedPorts.delete(port);
+
+    console.log(`[Server] Unexposed port: ${port}`);
+
+    return new Response(
+      JSON.stringify({
+        port,
+        success: true,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  } catch (error) {
+    console.error("[Server] Error in handleUnexposePortRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to unexpose port",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
+async function handleGetExposedPortsRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const ports = Array.from(exposedPorts.entries()).map(([port, info]) => ({
+      port,
+      name: info.name,
+      exposedAt: info.exposedAt.toISOString(),
+    }));
+
+    return new Response(
+      JSON.stringify({
+        ports,
+        count: ports.length,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  } catch (error) {
+    console.error("[Server] Error in handleGetExposedPortsRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to get exposed ports",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
+async function handleProxyRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const url = new URL(req.url);
+    const pathParts = url.pathname.split("/");
+
+    // Extract port from path like /proxy/3000/...
+    if (pathParts.length < 3) {
+      return new Response(
+        JSON.stringify({
+          error: "Invalid proxy path",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    const port = parseInt(pathParts[2]);
+    if (!port || Number.isNaN(port)) {
+      return new Response(
+        JSON.stringify({
+          error: "Invalid port in proxy path",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Check if port is exposed
+    if (!exposedPorts.has(port)) {
+      return new Response(
+        JSON.stringify({
+          error: `Port ${port} is not exposed`,
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 404,
+        }
+      );
+    }
+
+    // Construct the target URL
+    const targetPath = `/${pathParts.slice(3).join("/")}`;
+    // Use 127.0.0.1 instead of localhost for more reliable container networking
+    const targetUrl = `http://127.0.0.1:${port}${targetPath}${url.search}`;
+
+    console.log(`[Server] Proxying request to: ${targetUrl}`);
+    console.log(`[Server] Method: ${req.method}, Port: ${port}, Path: ${targetPath}`);
+
+    try {
+      // Forward the request to the target port
+      const targetResponse = await fetch(targetUrl, {
+        method: req.method,
+        headers: req.headers,
+        body: req.body,
+      });
+
+      // Return the response from the target
+      return new Response(targetResponse.body, {
+        status: targetResponse.status,
+        statusText: targetResponse.statusText,
+        headers: {
+          ...Object.fromEntries(targetResponse.headers.entries()),
+          ...corsHeaders,
+        },
+      });
+    } catch (fetchError) {
+      console.error(`[Server] Error proxying to port ${port}:`, fetchError);
+      return new Response(
+        JSON.stringify({
+          error: `Service on port ${port} is not responding`,
+          message: fetchError instanceof Error ? fetchError.message : "Unknown error",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 502,
+        }
+      );
+    }
+  } catch (error) {
+    console.error("[Server] Error in handleProxyRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to proxy request",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
 console.log(`🚀 Bun server running on http://0.0.0.0:${server.port}`);
 console.log(`📡 HTTP API endpoints available:`);
 console.log(`   POST /api/session/create - Create a new session`);
@@ -2902,5 +3188,9 @@ console.log(`   POST /api/rename - Rename a file`);
 console.log(`   POST /api/rename/stream - Rename a file (streaming)`);
 console.log(`   POST /api/move - Move a file`);
 console.log(`   POST /api/move/stream - Move a file (streaming)`);
+console.log(`   POST /api/expose-port - Expose a port for external access`);
+console.log(`   DELETE /api/unexpose-port - Unexpose a port`);
+console.log(`   GET  /api/exposed-ports - List exposed ports`);
+console.log(`   GET  /proxy/{port}/* - Proxy requests to exposed ports`);
 console.log(`   GET  /api/ping - Health check`);
 console.log(`   GET  /api/commands - List available commands`);