@cloudflare/sandbox 0.0.0-6d1b288 → 0.0.0-6f16c81

package/container_src/index.ts

@@ -1,11 +1,13 @@
-import { spawn } from "node:child_process";
-import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+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";
 
 interface ExecuteRequest {
   command: string;
   args?: string[];
+  sessionId?: string;
+  background?: boolean;
 }
 
 interface GitCheckoutRequest {
@@ -28,6 +30,12 @@ interface WriteFileRequest {
   sessionId?: string;
 }
 
+interface ReadFileRequest {
+  path: string;
+  encoding?: string;
+  sessionId?: string;
+}
+
 interface DeleteFileRequest {
   path: string;
   sessionId?: string;
@@ -45,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)}`;
@@ -78,6 +98,8 @@ const server = serve({
     const url = new URL(req.url);
     const pathname = url.pathname;
 
+    console.log(`[Container] Incoming ${req.method} request to ${pathname}`);
+
     // Handle CORS
     const corsHeaders = {
       "Access-Control-Allow-Headers": "Content-Type, Authorization",
@@ -87,11 +109,13 @@ const server = serve({
 
     // Handle preflight requests
     if (req.method === "OPTIONS") {
+      console.log(`[Container] Handling CORS preflight for ${pathname}`);
       return new Response(null, { headers: corsHeaders, status: 200 });
     }
 
     try {
       // Handle different routes
+      console.log(`[Container] Processing ${req.method} ${pathname}`);
       switch (pathname) {
         case "/":
           return new Response("Hello from Bun server! 🚀", {
@@ -101,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();
@@ -297,6 +276,18 @@ const server = serve({
           }
           break;
 
+        case "/api/read":
+          if (req.method === "POST") {
+            return handleReadFileRequest(req, corsHeaders);
+          }
+          break;
+
+        case "/api/read/stream":
+          if (req.method === "POST") {
+            return handleStreamingReadFileRequest(req, corsHeaders);
+          }
+          break;
+
         case "/api/delete":
           if (req.method === "POST") {
             return handleDeleteFileRequest(req, corsHeaders);
@@ -333,14 +324,38 @@ 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,
             status: 404,
           });
       }
     } catch (error) {
-      console.error("[Server] Error handling request:", error);
+      console.error(`[Container] Error handling ${req.method} ${pathname}:`, error);
       return new Response(
         JSON.stringify({
           error: "Internal server error",
@@ -356,16 +371,19 @@ 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(
@@ -412,7 +430,7 @@ async function handleExecuteRequest(
 
     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({
@@ -454,8 +472,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(
@@ -506,10 +524,13 @@ async function handleStreamingExecuteRequest(
 
     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)) {
@@ -517,6 +538,11 @@ async function handleStreamingExecuteRequest(
           session.activeProcess = child;
         }
 
+        // For background processes, unref to prevent blocking
+        if (background) {
+          child.unref();
+        }
+
         let stdout = "";
         let stderr = "";
 
@@ -528,6 +554,7 @@ async function handleStreamingExecuteRequest(
               command,
               timestamp: new Date().toISOString(),
               type: "command_start",
+              background: background || false,
             })}\n\n`
           )
         );
@@ -593,7 +620,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) => {
@@ -1476,13 +1507,13 @@ async function handleStreamingWriteFileRequest(
   }
 }
 
-async function handleDeleteFileRequest(
+async function handleReadFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as DeleteFileRequest;
-    const { path, sessionId } = body;
+    const body = (await req.json()) as ReadFileRequest;
+    const { path, encoding = "utf-8", sessionId } = body;
 
     if (!path || typeof path !== "string") {
       return new Response(
@@ -1530,12 +1561,13 @@ async function handleDeleteFileRequest(
       );
     }
 
-    console.log(`[Server] Deleting file: ${path}`);
+    console.log(`[Server] Reading file: ${path}`);
 
-    const result = await executeDeleteFile(path, sessionId);
+    const result = await executeReadFile(path, encoding, sessionId);
 
     return new Response(
       JSON.stringify({
+        content: result.content,
         exitCode: result.exitCode,
         path,
         success: result.success,
@@ -1549,10 +1581,10 @@ async function handleDeleteFileRequest(
       }
     );
   } catch (error) {
-    console.error("[Server] Error in handleDeleteFileRequest:", error);
+    console.error("[Server] Error in handleReadFileRequest:", error);
     return new Response(
       JSON.stringify({
-        error: "Failed to delete file",
+        error: "Failed to read file",
         message: error instanceof Error ? error.message : "Unknown error",
       }),
       {
@@ -1566,13 +1598,13 @@ async function handleDeleteFileRequest(
   }
 }
 
-async function handleStreamingDeleteFileRequest(
+async function handleStreamingReadFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as DeleteFileRequest;
-    const { path, sessionId } = body;
+    const body = (await req.json()) as ReadFileRequest;
+    const { path, encoding = "utf-8", sessionId } = body;
 
     if (!path || typeof path !== "string") {
       return new Response(
@@ -1620,7 +1652,7 @@ async function handleStreamingDeleteFileRequest(
       );
     }
 
-    console.log(`[Server] Deleting file (streaming): ${path}`);
+    console.log(`[Server] Reading file (streaming): ${path}`);
 
     const stream = new ReadableStream({
       start(controller) {
@@ -1637,15 +1669,18 @@ async function handleStreamingDeleteFileRequest(
               )
             );
 
-            // Delete the file
-            await executeDeleteFile(path, sessionId);
+            // Read the file
+            const content = await readFile(path, {
+              encoding: encoding as BufferEncoding,
+            });
 
-            console.log(`[Server] File deleted successfully: ${path}`);
+            console.log(`[Server] File read successfully: ${path}`);
 
             // Send command completion event
             controller.enqueue(
               new TextEncoder().encode(
                 `data: ${JSON.stringify({
+                  content,
                   path,
                   success: true,
                   timestamp: new Date().toISOString(),
@@ -1656,7 +1691,7 @@ async function handleStreamingDeleteFileRequest(
 
             controller.close();
           } catch (error) {
-            console.error(`[Server] Error deleting file: ${path}`, error);
+            console.error(`[Server] Error reading file: ${path}`, error);
 
             controller.enqueue(
               new TextEncoder().encode(
@@ -1684,10 +1719,10 @@ async function handleStreamingDeleteFileRequest(
       },
     });
   } catch (error) {
-    console.error("[Server] Error in handleStreamingDeleteFileRequest:", error);
+    console.error("[Server] Error in handleStreamingReadFileRequest:", error);
     return new Response(
       JSON.stringify({
-        error: "Failed to delete file",
+        error: "Failed to read file",
         message: error instanceof Error ? error.message : "Unknown error",
       }),
       {
@@ -1701,33 +1736,18 @@ async function handleStreamingDeleteFileRequest(
   }
 }
 
-async function handleRenameFileRequest(
+async function handleDeleteFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as RenameFileRequest;
-    const { oldPath, newPath, sessionId } = body;
-
-    if (!oldPath || typeof oldPath !== "string") {
-      return new Response(
-        JSON.stringify({
-          error: "Old path is required and must be a string",
-        }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...corsHeaders,
-          },
-          status: 400,
-        }
-      );
-    }
+    const body = (await req.json()) as DeleteFileRequest;
+    const { path, sessionId } = body;
 
-    if (!newPath || typeof newPath !== "string") {
+    if (!path || typeof path !== "string") {
       return new Response(
         JSON.stringify({
-          error: "New path is required and must be a string",
+          error: "Path is required and must be a string",
         }),
         {
           headers: {
@@ -1755,11 +1775,7 @@ async function handleRenameFileRequest(
       /\.\./, // Path traversal attempts
     ];
 
-    if (
-      dangerousPatterns.some(
-        (pattern) => pattern.test(oldPath) || pattern.test(newPath)
-      )
-    ) {
+    if (dangerousPatterns.some((pattern) => pattern.test(path))) {
       return new Response(
         JSON.stringify({
           error: "Dangerous path not allowed",
@@ -1774,15 +1790,14 @@ async function handleRenameFileRequest(
       );
     }
 
-    console.log(`[Server] Renaming file: ${oldPath} -> ${newPath}`);
+    console.log(`[Server] Deleting file: ${path}`);
 
-    const result = await executeRenameFile(oldPath, newPath, sessionId);
+    const result = await executeDeleteFile(path, sessionId);
 
     return new Response(
       JSON.stringify({
         exitCode: result.exitCode,
-        newPath,
-        oldPath,
+        path,
         success: result.success,
         timestamp: new Date().toISOString(),
       }),
@@ -1794,10 +1809,10 @@ async function handleRenameFileRequest(
       }
     );
   } catch (error) {
-    console.error("[Server] Error in handleRenameFileRequest:", error);
+    console.error("[Server] Error in handleDeleteFileRequest:", error);
     return new Response(
       JSON.stringify({
-        error: "Failed to rename file",
+        error: "Failed to delete file",
         message: error instanceof Error ? error.message : "Unknown error",
       }),
       {
@@ -1811,33 +1826,18 @@ async function handleRenameFileRequest(
   }
 }
 
-async function handleStreamingRenameFileRequest(
+async function handleStreamingDeleteFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as RenameFileRequest;
-    const { oldPath, newPath, sessionId } = body;
-
-    if (!oldPath || typeof oldPath !== "string") {
-      return new Response(
-        JSON.stringify({
-          error: "Old path is required and must be a string",
-        }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...corsHeaders,
-          },
-          status: 400,
-        }
-      );
-    }
+    const body = (await req.json()) as DeleteFileRequest;
+    const { path, sessionId } = body;
 
-    if (!newPath || typeof newPath !== "string") {
+    if (!path || typeof path !== "string") {
       return new Response(
         JSON.stringify({
-          error: "New path is required and must be a string",
+          error: "Path is required and must be a string",
         }),
         {
           headers: {
@@ -1865,11 +1865,7 @@ async function handleStreamingRenameFileRequest(
       /\.\./, // Path traversal attempts
     ];
 
-    if (
-      dangerousPatterns.some(
-        (pattern) => pattern.test(oldPath) || pattern.test(newPath)
-      )
-    ) {
+    if (dangerousPatterns.some((pattern) => pattern.test(path))) {
       return new Response(
         JSON.stringify({
           error: "Dangerous path not allowed",
@@ -1884,7 +1880,7 @@ async function handleStreamingRenameFileRequest(
       );
     }
 
-    console.log(`[Server] Renaming file (streaming): ${oldPath} -> ${newPath}`);
+    console.log(`[Server] Deleting file (streaming): ${path}`);
 
     const stream = new ReadableStream({
       start(controller) {
@@ -1894,27 +1890,23 @@ async function handleStreamingRenameFileRequest(
             controller.enqueue(
               new TextEncoder().encode(
                 `data: ${JSON.stringify({
-                  newPath,
-                  oldPath,
+                  path,
                   timestamp: new Date().toISOString(),
                   type: "command_start",
                 })}\n\n`
               )
             );
 
-            // Rename the file
-            await executeRenameFile(oldPath, newPath, sessionId);
+            // Delete the file
+            await executeDeleteFile(path, sessionId);
 
-            console.log(
-              `[Server] File renamed successfully: ${oldPath} -> ${newPath}`
-            );
+            console.log(`[Server] File deleted successfully: ${path}`);
 
             // Send command completion event
             controller.enqueue(
               new TextEncoder().encode(
                 `data: ${JSON.stringify({
-                  newPath,
-                  oldPath,
+                  path,
                   success: true,
                   timestamp: new Date().toISOString(),
                   type: "command_complete",
@@ -1924,18 +1916,14 @@ async function handleStreamingRenameFileRequest(
 
             controller.close();
           } catch (error) {
-            console.error(
-              `[Server] Error renaming file: ${oldPath} -> ${newPath}`,
-              error
-            );
+            console.error(`[Server] Error deleting file: ${path}`, error);
 
             controller.enqueue(
               new TextEncoder().encode(
                 `data: ${JSON.stringify({
                   error:
                     error instanceof Error ? error.message : "Unknown error",
-                  newPath,
-                  oldPath,
+                  path,
                   type: "error",
                 })}\n\n`
               )
@@ -1956,10 +1944,10 @@ async function handleStreamingRenameFileRequest(
       },
     });
   } catch (error) {
-    console.error("[Server] Error in handleStreamingRenameFileRequest:", error);
+    console.error("[Server] Error in handleStreamingDeleteFileRequest:", error);
     return new Response(
       JSON.stringify({
-        error: "Failed to rename file",
+        error: "Failed to delete file",
         message: error instanceof Error ? error.message : "Unknown error",
       }),
       {
@@ -1973,18 +1961,18 @@ async function handleStreamingRenameFileRequest(
   }
 }
 
-async function handleMoveFileRequest(
+async function handleRenameFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as MoveFileRequest;
-    const { sourcePath, destinationPath, sessionId } = body;
+    const body = (await req.json()) as RenameFileRequest;
+    const { oldPath, newPath, sessionId } = body;
 
-    if (!sourcePath || typeof sourcePath !== "string") {
+    if (!oldPath || typeof oldPath !== "string") {
       return new Response(
         JSON.stringify({
-          error: "Source path is required and must be a string",
+          error: "Old path is required and must be a string",
         }),
         {
           headers: {
@@ -1996,10 +1984,10 @@ async function handleMoveFileRequest(
       );
     }
 
-    if (!destinationPath || typeof destinationPath !== "string") {
+    if (!newPath || typeof newPath !== "string") {
       return new Response(
         JSON.stringify({
-          error: "Destination path is required and must be a string",
+          error: "New path is required and must be a string",
         }),
         {
           headers: {
@@ -2029,7 +2017,7 @@ async function handleMoveFileRequest(
 
     if (
       dangerousPatterns.some(
-        (pattern) => pattern.test(sourcePath) || pattern.test(destinationPath)
+        (pattern) => pattern.test(oldPath) || pattern.test(newPath)
       )
     ) {
       return new Response(
@@ -2046,19 +2034,15 @@ async function handleMoveFileRequest(
       );
     }
 
-    console.log(`[Server] Moving file: ${sourcePath} -> ${destinationPath}`);
+    console.log(`[Server] Renaming file: ${oldPath} -> ${newPath}`);
 
-    const result = await executeMoveFile(
-      sourcePath,
-      destinationPath,
-      sessionId
-    );
+    const result = await executeRenameFile(oldPath, newPath, sessionId);
 
     return new Response(
       JSON.stringify({
-        destinationPath,
         exitCode: result.exitCode,
-        sourcePath,
+        newPath,
+        oldPath,
         success: result.success,
         timestamp: new Date().toISOString(),
       }),
@@ -2070,10 +2054,10 @@ async function handleMoveFileRequest(
       }
     );
   } catch (error) {
-    console.error("[Server] Error in handleMoveFileRequest:", error);
+    console.error("[Server] Error in handleRenameFileRequest:", error);
     return new Response(
       JSON.stringify({
-        error: "Failed to move file",
+        error: "Failed to rename file",
         message: error instanceof Error ? error.message : "Unknown error",
       }),
       {
@@ -2087,18 +2071,18 @@ async function handleMoveFileRequest(
   }
 }
 
-async function handleStreamingMoveFileRequest(
+async function handleStreamingRenameFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
 ): Promise<Response> {
   try {
-    const body = (await req.json()) as MoveFileRequest;
-    const { sourcePath, destinationPath, sessionId } = body;
+    const body = (await req.json()) as RenameFileRequest;
+    const { oldPath, newPath, sessionId } = body;
 
-    if (!sourcePath || typeof sourcePath !== "string") {
+    if (!oldPath || typeof oldPath !== "string") {
       return new Response(
         JSON.stringify({
-          error: "Source path is required and must be a string",
+          error: "Old path is required and must be a string",
         }),
         {
           headers: {
@@ -2110,10 +2094,10 @@ async function handleStreamingMoveFileRequest(
       );
     }
 
-    if (!destinationPath || typeof destinationPath !== "string") {
+    if (!newPath || typeof newPath !== "string") {
       return new Response(
         JSON.stringify({
-          error: "Destination path is required and must be a string",
+          error: "New path is required and must be a string",
         }),
         {
           headers: {
@@ -2143,7 +2127,7 @@ async function handleStreamingMoveFileRequest(
 
     if (
       dangerousPatterns.some(
-        (pattern) => pattern.test(sourcePath) || pattern.test(destinationPath)
+        (pattern) => pattern.test(oldPath) || pattern.test(newPath)
       )
     ) {
       return new Response(
@@ -2160,9 +2144,7 @@ async function handleStreamingMoveFileRequest(
       );
     }
 
-    console.log(
-      `[Server] Moving file (streaming): ${sourcePath} -> ${destinationPath}`
-    );
+    console.log(`[Server] Renaming file (streaming): ${oldPath} -> ${newPath}`);
 
     const stream = new ReadableStream({
       start(controller) {
@@ -2172,27 +2154,27 @@ async function handleStreamingMoveFileRequest(
             controller.enqueue(
               new TextEncoder().encode(
                 `data: ${JSON.stringify({
-                  destinationPath,
-                  sourcePath,
+                  newPath,
+                  oldPath,
                   timestamp: new Date().toISOString(),
                   type: "command_start",
                 })}\n\n`
               )
             );
 
-            // Move the file
-            await executeMoveFile(sourcePath, destinationPath, sessionId);
+            // Rename the file
+            await executeRenameFile(oldPath, newPath, sessionId);
 
             console.log(
-              `[Server] File moved successfully: ${sourcePath} -> ${destinationPath}`
+              `[Server] File renamed successfully: ${oldPath} -> ${newPath}`
             );
 
             // Send command completion event
             controller.enqueue(
               new TextEncoder().encode(
                 `data: ${JSON.stringify({
-                  destinationPath,
-                  sourcePath,
+                  newPath,
+                  oldPath,
                   success: true,
                   timestamp: new Date().toISOString(),
                   type: "command_complete",
@@ -2203,14 +2185,292 @@ async function handleStreamingMoveFileRequest(
             controller.close();
           } catch (error) {
             console.error(
-              `[Server] Error moving file: ${sourcePath} -> ${destinationPath}`,
+              `[Server] Error renaming file: ${oldPath} -> ${newPath}`,
               error
             );
 
             controller.enqueue(
               new TextEncoder().encode(
                 `data: ${JSON.stringify({
-                  destinationPath,
+                  error:
+                    error instanceof Error ? error.message : "Unknown error",
+                  newPath,
+                  oldPath,
+                  type: "error",
+                })}\n\n`
+              )
+            );
+
+            controller.close();
+          }
+        })();
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Content-Type": "text/event-stream",
+        ...corsHeaders,
+      },
+    });
+  } catch (error) {
+    console.error("[Server] Error in handleStreamingRenameFileRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to rename file",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
+async function handleMoveFileRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as MoveFileRequest;
+    const { sourcePath, destinationPath, sessionId } = body;
+
+    if (!sourcePath || typeof sourcePath !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "Source path is required and must be a string",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    if (!destinationPath || typeof destinationPath !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "Destination path is required and must be a string",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Basic safety check - prevent dangerous paths
+    const dangerousPatterns = [
+      /^\/$/, // Root directory
+      /^\/etc/, // System directories
+      /^\/var/, // System directories
+      /^\/usr/, // System directories
+      /^\/bin/, // System directories
+      /^\/sbin/, // System directories
+      /^\/boot/, // System directories
+      /^\/dev/, // System directories
+      /^\/proc/, // System directories
+      /^\/sys/, // System directories
+      /^\/tmp\/\.\./, // Path traversal attempts
+      /\.\./, // Path traversal attempts
+    ];
+
+    if (
+      dangerousPatterns.some(
+        (pattern) => pattern.test(sourcePath) || pattern.test(destinationPath)
+      )
+    ) {
+      return new Response(
+        JSON.stringify({
+          error: "Dangerous path not allowed",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    console.log(`[Server] Moving file: ${sourcePath} -> ${destinationPath}`);
+
+    const result = await executeMoveFile(
+      sourcePath,
+      destinationPath,
+      sessionId
+    );
+
+    return new Response(
+      JSON.stringify({
+        destinationPath,
+        exitCode: result.exitCode,
+        sourcePath,
+        success: result.success,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  } catch (error) {
+    console.error("[Server] Error in handleMoveFileRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to move file",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
+async function handleStreamingMoveFileRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as MoveFileRequest;
+    const { sourcePath, destinationPath, sessionId } = body;
+
+    if (!sourcePath || typeof sourcePath !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "Source path is required and must be a string",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    if (!destinationPath || typeof destinationPath !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "Destination path is required and must be a string",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    // Basic safety check - prevent dangerous paths
+    const dangerousPatterns = [
+      /^\/$/, // Root directory
+      /^\/etc/, // System directories
+      /^\/var/, // System directories
+      /^\/usr/, // System directories
+      /^\/bin/, // System directories
+      /^\/sbin/, // System directories
+      /^\/boot/, // System directories
+      /^\/dev/, // System directories
+      /^\/proc/, // System directories
+      /^\/sys/, // System directories
+      /^\/tmp\/\.\./, // Path traversal attempts
+      /\.\./, // Path traversal attempts
+    ];
+
+    if (
+      dangerousPatterns.some(
+        (pattern) => pattern.test(sourcePath) || pattern.test(destinationPath)
+      )
+    ) {
+      return new Response(
+        JSON.stringify({
+          error: "Dangerous path not allowed",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    console.log(
+      `[Server] Moving file (streaming): ${sourcePath} -> ${destinationPath}`
+    );
+
+    const stream = new ReadableStream({
+      start(controller) {
+        (async () => {
+          try {
+            // Send command start event
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  destinationPath,
+                  sourcePath,
+                  timestamp: new Date().toISOString(),
+                  type: "command_start",
+                })}\n\n`
+              )
+            );
+
+            // Move the file
+            await executeMoveFile(sourcePath, destinationPath, sessionId);
+
+            console.log(
+              `[Server] File moved successfully: ${sourcePath} -> ${destinationPath}`
+            );
+
+            // Send command completion event
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  destinationPath,
+                  sourcePath,
+                  success: true,
+                  timestamp: new Date().toISOString(),
+                  type: "command_complete",
+                })}\n\n`
+              )
+            );
+
+            controller.close();
+          } catch (error) {
+            console.error(
+              `[Server] Error moving file: ${sourcePath} -> ${destinationPath}`,
+              error
+            );
+
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  destinationPath,
                   error:
                     error instanceof Error ? error.message : "Unknown error",
                   sourcePath,
@@ -2254,7 +2514,8 @@ async function handleStreamingMoveFileRequest(
 function executeCommand(
   command: string,
   args: string[],
-  sessionId?: string
+  sessionId?: string,
+  background?: boolean
 ): Promise<{
   success: boolean;
   stdout: string;
@@ -2262,10 +2523,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)) {
@@ -2284,32 +2548,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);
+      });
+    }
   });
 }
 
@@ -2506,6 +2792,37 @@ function executeWriteFile(
   });
 }
 
+function executeReadFile(
+  path: string,
+  encoding: string,
+  sessionId?: string
+): Promise<{
+  success: boolean;
+  exitCode: number;
+  content: string;
+}> {
+  return new Promise((resolve, reject) => {
+    (async () => {
+      try {
+        // Read the file
+        const content = await readFile(path, {
+          encoding: encoding as BufferEncoding,
+        });
+
+        console.log(`[Server] File read successfully: ${path}`);
+        resolve({
+          content,
+          exitCode: 0,
+          success: true,
+        });
+      } catch (error) {
+        console.error(`[Server] Error reading file: ${path}`, error);
+        reject(error);
+      }
+    })();
+  });
+}
+
 function executeDeleteFile(
   path: string,
   sessionId?: string
@@ -2596,7 +2913,316 @@ function executeMoveFile(
   });
 }
 
-console.log(`🚀 Bun server running on http://localhost:${server.port}`);
+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`);
 console.log(`   GET  /api/session/list - List all sessions`);
@@ -2610,11 +3236,17 @@ console.log(`   POST /api/mkdir - Create a directory`);
 console.log(`   POST /api/mkdir/stream - Create a directory (streaming)`);
 console.log(`   POST /api/write - Write a file`);
 console.log(`   POST /api/write/stream - Write a file (streaming)`);
+console.log(`   POST /api/read - Read a file`);
+console.log(`   POST /api/read/stream - Read a file (streaming)`);
 console.log(`   POST /api/delete - Delete a file`);
 console.log(`   POST /api/delete/stream - Delete a file (streaming)`);
 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`);