@cloudflare/sandbox 0.0.1 → 0.0.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @cloudflare/sandbox
 
+## 0.0.3
+
+### Patch Changes
+
+- [`2b087c4`](https://github.com/cloudflare/sandbox-sdk/commit/2b087c40a29697c20dad19b4e3b8512f5d404bd3) Thanks [@ghostwriternr](https://github.com/ghostwriternr)! - Fix worker unable to find container port
+
+## 0.0.2
+
+### Patch Changes
+
+- [`52f02f0`](https://github.com/cloudflare/sandbox-sdk/commit/52f02f0625ef9f8eac695e51f93fa79651c0206d) Thanks [@threepointone](https://github.com/threepointone)! - readFile
+
 ## 0.0.1
 
 ### Patch Changes

package/README.md

@@ -56,6 +56,7 @@ export default {
 - `gitCheckout(repoUrl: string, options: { branch?: string; targetDir?: string; stream?: boolean })`: Checkout a git repository in the sandbox.
 - `mkdir(path: string, options: { recursive?: boolean; stream?: boolean })`: Create a directory in the sandbox.
 - `writeFile(path: string, content: string, options: { encoding?: string; stream?: boolean })`: Write content to a file in the sandbox.
+- `readFile(path: string, options: { encoding?: string; stream?: boolean })`: Read content from a file in the sandbox.
 - `deleteFile(path: string, options?: { stream?: boolean })`: Delete a file from the sandbox.
 - `renameFile(oldPath: string, newPath: string, options?: { stream?: boolean })`: Rename a file in the sandbox.
 - `moveFile(sourcePath: string, destinationPath: string, options?: { stream?: boolean })`: Move a file from one location to another in the sandbox.

package/container_src/index.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { serve } from "bun";
 
@@ -28,6 +28,12 @@ interface WriteFileRequest {
   sessionId?: string;
 }
 
+interface ReadFileRequest {
+  path: string;
+  encoding?: string;
+  sessionId?: string;
+}
+
 interface DeleteFileRequest {
   path: string;
   sessionId?: string;
@@ -297,6 +303,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);
@@ -1476,6 +1494,235 @@ async function handleStreamingWriteFileRequest(
   }
 }
 
+async function handleReadFileRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as ReadFileRequest;
+    const { path, encoding = "utf-8", sessionId } = body;
+
+    if (!path || typeof path !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "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(path))) {
+      return new Response(
+        JSON.stringify({
+          error: "Dangerous path not allowed",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    console.log(`[Server] Reading file: ${path}`);
+
+    const result = await executeReadFile(path, encoding, sessionId);
+
+    return new Response(
+      JSON.stringify({
+        content: result.content,
+        exitCode: result.exitCode,
+        path,
+        success: result.success,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      }
+    );
+  } catch (error) {
+    console.error("[Server] Error in handleReadFileRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to read file",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
+async function handleStreamingReadFileRequest(
+  req: Request,
+  corsHeaders: Record<string, string>
+): Promise<Response> {
+  try {
+    const body = (await req.json()) as ReadFileRequest;
+    const { path, encoding = "utf-8", sessionId } = body;
+
+    if (!path || typeof path !== "string") {
+      return new Response(
+        JSON.stringify({
+          error: "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(path))) {
+      return new Response(
+        JSON.stringify({
+          error: "Dangerous path not allowed",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+          },
+          status: 400,
+        }
+      );
+    }
+
+    console.log(`[Server] Reading file (streaming): ${path}`);
+
+    const stream = new ReadableStream({
+      start(controller) {
+        (async () => {
+          try {
+            // Send command start event
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  path,
+                  timestamp: new Date().toISOString(),
+                  type: "command_start",
+                })}\n\n`
+              )
+            );
+
+            // Read the file
+            const content = await readFile(path, {
+              encoding: encoding as BufferEncoding,
+            });
+
+            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(),
+                  type: "command_complete",
+                })}\n\n`
+              )
+            );
+
+            controller.close();
+          } catch (error) {
+            console.error(`[Server] Error reading file: ${path}`, error);
+
+            controller.enqueue(
+              new TextEncoder().encode(
+                `data: ${JSON.stringify({
+                  error:
+                    error instanceof Error ? error.message : "Unknown error",
+                  path,
+                  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 handleStreamingReadFileRequest:", error);
+    return new Response(
+      JSON.stringify({
+        error: "Failed to read file",
+        message: error instanceof Error ? error.message : "Unknown error",
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+        status: 500,
+      }
+    );
+  }
+}
+
 async function handleDeleteFileRequest(
   req: Request,
   corsHeaders: Record<string, string>
@@ -2506,6 +2753,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
@@ -2610,6 +2888,8 @@ 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`);

package/dist/{chunk-GYEDSCAB.js → chunk-N6VMTCTA.js}

@@ -626,6 +626,130 @@ var HttpClient = class {
       throw error;
     }
   }
+  async readFile(path, encoding = "utf-8", sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/read`, {
+        body: JSON.stringify({
+          encoding,
+          path,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] File read: ${path}, Success: ${data.success}, Content length: ${data.content.length}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error reading file:", error);
+      throw error;
+    }
+  }
+  async readFileStream(path, encoding = "utf-8", sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/read/stream`, {
+        body: JSON.stringify({
+          encoding,
+          path,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("No response body for streaming request");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          const chunk = decoder.decode(value, { stream: true });
+          const lines = chunk.split("\n");
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const eventData = line.slice(6);
+                const event = JSON.parse(eventData);
+                console.log(
+                  `[HTTP Client] Read file stream event: ${event.type}`
+                );
+                this.options.onStreamEvent?.(event);
+                switch (event.type) {
+                  case "command_start":
+                    console.log(
+                      `[HTTP Client] Read file started: ${event.path}`
+                    );
+                    this.options.onCommandStart?.("read", [path, encoding]);
+                    break;
+                  case "command_complete":
+                    console.log(
+                      `[HTTP Client] Read file completed: ${event.path}, Success: ${event.success}, Content length: ${event.content?.length || 0}`
+                    );
+                    this.options.onCommandComplete?.(
+                      event.success,
+                      0,
+                      event.content || "",
+                      "",
+                      "read",
+                      [path, encoding]
+                    );
+                    break;
+                  case "error":
+                    console.error(
+                      `[HTTP Client] Read file error: ${event.error}`
+                    );
+                    this.options.onError?.(event.error, "read", [
+                      path,
+                      encoding
+                    ]);
+                    break;
+                }
+              } catch (parseError) {
+                console.warn(
+                  "[HTTP Client] Failed to parse read file stream event:",
+                  parseError
+                );
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    } catch (error) {
+      console.error("[HTTP Client] Error in streaming read file:", error);
+      this.options.onError?.(
+        error instanceof Error ? error.message : "Unknown error",
+        "read",
+        [path, encoding]
+      );
+      throw error;
+    }
+  }
   async deleteFile(path, sessionId) {
     try {
       const targetSessionId = sessionId || this.sessionId;
@@ -1121,6 +1245,24 @@ async function quickWriteFileStream(path, content, encoding = "utf-8", options)
     client.clearSession();
   }
 }
+async function quickReadFile(path, encoding = "utf-8", options) {
+  const client = createClient(options);
+  await client.createSession();
+  try {
+    return await client.readFile(path, encoding);
+  } finally {
+    client.clearSession();
+  }
+}
+async function quickReadFileStream(path, encoding = "utf-8", options) {
+  const client = createClient(options);
+  await client.createSession();
+  try {
+    await client.readFileStream(path, encoding);
+  } finally {
+    client.clearSession();
+  }
+}
 async function quickDeleteFile(path, options) {
   const client = createClient(options);
   await client.createSession();
@@ -1187,6 +1329,8 @@ export {
   quickMkdirStream,
   quickWriteFile,
   quickWriteFileStream,
+  quickReadFile,
+  quickReadFileStream,
   quickDeleteFile,
   quickDeleteFileStream,
   quickRenameFile,
@@ -1194,4 +1338,4 @@ export {
   quickMoveFile,
   quickMoveFileStream
 };
-//# sourceMappingURL=chunk-GYEDSCAB.js.map
+//# sourceMappingURL=chunk-N6VMTCTA.js.map