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

package/package.json

@@ -1,12 +1,25 @@
 {
   "name": "@cloudflare/sandbox",
-  "version": "0.0.0-6d1b288",
+  "version": "0.0.0-6f16c81",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cloudflare/sandbox-sdk"
+  },
   "description": "A sandboxed environment for running commands",
   "dependencies": {
-    "@cloudflare/containers": "^0.0.8"
+    "@cloudflare/containers": "^0.0.23"
   },
+  "tags": [
+    "sandbox",
+    "codegen",
+    "containers",
+    "cloudflare",
+    "durable objects"
+  ],
   "scripts": {
-    "build": "tsup src/*.ts --outDir dist --dts --sourcemap --format esm"
+    "build": "rm -rf dist && tsup src/*.ts --outDir dist --dts --sourcemap --format esm",
+    "docker:build": "docker build -t ghostwriternr/cloudflare-sandbox:$npm_package_version .",
+    "docker:publish": "docker push docker.io/ghostwriternr/cloudflare-sandbox:$npm_package_version"
   },
   "exports": {
     ".": {

package/src/client.ts

@@ -1,9 +1,10 @@
-import type { DurableObject } from "cloudflare:workers";
 import type { Sandbox } from "./index";
 
 interface ExecuteRequest {
   command: string;
   args?: string[];
+  sessionId?: string;
+  background?: boolean;
 }
 
 export interface ExecuteResponse {
@@ -85,6 +86,20 @@ export interface WriteFileResponse {
   timestamp: string;
 }
 
+interface ReadFileRequest {
+  path: string;
+  encoding?: string;
+  sessionId?: string;
+}
+
+export interface ReadFileResponse {
+  success: boolean;
+  exitCode: number;
+  path: string;
+  content: string;
+  timestamp: string;
+}
+
 interface DeleteFileRequest {
   path: string;
   sessionId?: string;
@@ -125,6 +140,37 @@ export interface MoveFileResponse {
   timestamp: string;
 }
 
+interface PreviewInfo {
+  url: string;
+  port: number;
+  name?: string;
+}
+
+interface ExposedPort extends PreviewInfo {
+  exposedAt: string;
+  timestamp: string;
+}
+
+interface ExposePortResponse {
+  success: boolean;
+  port: number;
+  name?: string;
+  exposedAt: string;
+  timestamp: string;
+}
+
+interface UnexposePortResponse {
+  success: boolean;
+  port: number;
+  timestamp: string;
+}
+
+interface GetExposedPortsResponse {
+  ports: ExposedPort[];
+  count: number;
+  timestamp: string;
+}
+
 interface PingResponse {
   message: string;
   timestamp: string;
@@ -142,6 +188,7 @@ interface StreamEvent {
   newPath?: string;
   sourcePath?: string;
   destinationPath?: string;
+  content?: string;
   success?: boolean;
   exitCode?: number;
   stdout?: string;
@@ -188,10 +235,41 @@ export class HttpClient {
     path: string,
     options?: RequestInit
   ): Promise<Response> {
-    if (this.options.stub) {
-      return this.options.stub.containerFetch(path, options, this.options.port);
+    const url = this.options.stub
+      ? `http://localhost:${this.options.port}${path}`
+      : `${this.baseUrl}${path}`;
+    const method = options?.method || "GET";
+
+    console.log(`[HTTP Client] Making ${method} request to ${url}`);
+
+    try {
+      let response: Response;
+
+      if (this.options.stub) {
+        response = await this.options.stub.containerFetch(
+          url,
+          options,
+          this.options.port
+        );
+      } else {
+        response = await fetch(url, options);
+      }
+
+      console.log(
+        `[HTTP Client] Response: ${response.status} ${response.statusText}`
+      );
+
+      if (!response.ok) {
+        console.error(
+          `[HTTP Client] Request failed: ${method} ${url} - ${response.status} ${response.statusText}`
+        );
+      }
+
+      return response;
+    } catch (error) {
+      console.error(`[HTTP Client] Request error: ${method} ${url}`, error);
+      throw error;
     }
-    return fetch(this.baseUrl + path, options);
   }
   // Public methods to set event handlers
   setOnOutput(
@@ -230,13 +308,13 @@ export class HttpClient {
 
   getOnCommandComplete():
     | ((
-        success: boolean,
-        exitCode: number,
-        stdout: string,
-        stderr: string,
-        command: string,
-        args: string[]
-      ) => void)
+      success: boolean,
+      exitCode: number,
+      stdout: string,
+      stderr: string,
+      command: string,
+      args: string[]
+    ) => void)
     | undefined {
     return this.options.onCommandComplete;
   }
@@ -293,7 +371,8 @@ export class HttpClient {
   async execute(
     command: string,
     args: string[] = [],
-    sessionId?: string
+    sessionId?: string,
+    background: boolean = false,
   ): Promise<ExecuteResponse> {
     try {
       const targetSessionId = sessionId || this.sessionId;
@@ -302,8 +381,9 @@ export class HttpClient {
         body: JSON.stringify({
           args,
           command,
+          background,
           sessionId: targetSessionId,
-        }),
+        } as ExecuteRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -349,7 +429,8 @@ export class HttpClient {
   async executeStream(
     command: string,
     args: string[] = [],
-    sessionId?: string
+    sessionId?: string,
+    background: boolean = false
   ): Promise<void> {
     try {
       const targetSessionId = sessionId || this.sessionId;
@@ -358,6 +439,7 @@ export class HttpClient {
         body: JSON.stringify({
           args,
           command,
+          background,
           sessionId: targetSessionId,
         }),
         headers: {
@@ -405,8 +487,7 @@ export class HttpClient {
                 switch (event.type) {
                   case "command_start":
                     console.log(
-                      `[HTTP Client] Command started: ${
-                        event.command
+                      `[HTTP Client] Command started: ${event.command
                       } ${event.args?.join(" ")}`
                     );
                     this.options.onCommandStart?.(
@@ -487,7 +568,7 @@ export class HttpClient {
           repoUrl,
           sessionId: targetSessionId,
           targetDir,
-        }),
+        } as GitCheckoutRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -578,8 +659,7 @@ export class HttpClient {
                 switch (event.type) {
                   case "command_start":
                     console.log(
-                      `[HTTP Client] Git checkout started: ${
-                        event.command
+                      `[HTTP Client] Git checkout started: ${event.command
                       } ${event.args?.join(" ")}`
                     );
                     this.options.onCommandStart?.(
@@ -658,7 +738,7 @@ export class HttpClient {
           path,
           recursive,
           sessionId: targetSessionId,
-        }),
+        } as MkdirRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -699,7 +779,7 @@ export class HttpClient {
           path,
           recursive,
           sessionId: targetSessionId,
-        }),
+        } as MkdirRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -745,8 +825,7 @@ export class HttpClient {
                 switch (event.type) {
                   case "command_start":
                     console.log(
-                      `[HTTP Client] Mkdir started: ${
-                        event.command
+                      `[HTTP Client] Mkdir started: ${event.command
                       } ${event.args?.join(" ")}`
                     );
                     this.options.onCommandStart?.(
@@ -825,7 +904,7 @@ export class HttpClient {
           encoding,
           path,
           sessionId: targetSessionId,
-        }),
+        } as WriteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -868,7 +947,7 @@ export class HttpClient {
           encoding,
           path,
           sessionId: targetSessionId,
-        }),
+        } as WriteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -978,6 +1057,162 @@ export class HttpClient {
     }
   }
 
+  async readFile(
+    path: string,
+    encoding: string = "utf-8",
+    sessionId?: string
+  ): Promise<ReadFileResponse> {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+
+      const response = await this.doFetch(`/api/read`, {
+        body: JSON.stringify({
+          encoding,
+          path,
+          sessionId: targetSessionId,
+        } as ReadFileRequest),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      const data: ReadFileResponse = 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: string,
+    encoding: string = "utf-8",
+    sessionId?: string
+  ): Promise<void> {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+
+      const response = await this.doFetch(`/api/read/stream`, {
+        body: JSON.stringify({
+          encoding,
+          path,
+          sessionId: targetSessionId,
+        } as ReadFileRequest),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        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); // Remove 'data: ' prefix
+                const event: StreamEvent = 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: string,
     sessionId?: string
@@ -989,7 +1224,7 @@ export class HttpClient {
         body: JSON.stringify({
           path,
           sessionId: targetSessionId,
-        }),
+        } as DeleteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1025,7 +1260,7 @@ export class HttpClient {
         body: JSON.stringify({
           path,
           sessionId: targetSessionId,
-        }),
+        } as DeleteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1135,7 +1370,7 @@ export class HttpClient {
           newPath,
           oldPath,
           sessionId: targetSessionId,
-        }),
+        } as RenameFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1176,7 +1411,7 @@ export class HttpClient {
           newPath,
           oldPath,
           sessionId: targetSessionId,
-        }),
+        } as RenameFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1289,7 +1524,7 @@ export class HttpClient {
           destinationPath,
           sessionId: targetSessionId,
           sourcePath,
-        }),
+        } as MoveFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1330,7 +1565,7 @@ export class HttpClient {
           destinationPath,
           sessionId: targetSessionId,
           sourcePath,
-        }),
+        } as MoveFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1433,6 +1668,104 @@ export class HttpClient {
     }
   }
 
+  async exposePort(port: number, name?: string): Promise<ExposePortResponse> {
+    try {
+      const response = await this.doFetch(`/api/expose-port`, {
+        body: JSON.stringify({
+          port,
+          name,
+        }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        console.log(errorData);
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      const data: ExposePortResponse = await response.json();
+      console.log(
+        `[HTTP Client] Port exposed: ${port}${name ? ` (${name})` : ""}, Success: ${data.success}`
+      );
+
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error exposing port:", error);
+      throw error;
+    }
+  }
+
+  async unexposePort(port: number): Promise<UnexposePortResponse> {
+    try {
+      const response = await this.doFetch(`/api/unexpose-port`, {
+        body: JSON.stringify({
+          port,
+        }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "DELETE",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      const data: UnexposePortResponse = await response.json();
+      console.log(
+        `[HTTP Client] Port unexposed: ${port}, Success: ${data.success}`
+      );
+
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error unexposing port:", error);
+      throw error;
+    }
+  }
+
+  async getExposedPorts(): Promise<GetExposedPortsResponse> {
+    try {
+      const response = await this.doFetch(`/api/exposed-ports`, {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "GET",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      const data: GetExposedPortsResponse = await response.json();
+      console.log(
+        `[HTTP Client] Got ${data.count} exposed ports`
+      );
+
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error getting exposed ports:", error);
+      throw error;
+    }
+  }
+
   async ping(): Promise<string> {
     try {
       const response = await this.doFetch(`/api/ping`, {
@@ -1629,6 +1962,38 @@ export async function quickWriteFileStream(
   }
 }
 
+// Convenience function for quick file reading
+export async function quickReadFile(
+  path: string,
+  encoding: string = "utf-8",
+  options?: HttpClientOptions
+): Promise<ReadFileResponse> {
+  const client = createClient(options);
+  await client.createSession();
+
+  try {
+    return await client.readFile(path, encoding);
+  } finally {
+    client.clearSession();
+  }
+}
+
+// Convenience function for quick streaming file reading
+export async function quickReadFileStream(
+  path: string,
+  encoding: string = "utf-8",
+  options?: HttpClientOptions
+): Promise<void> {
+  const client = createClient(options);
+  await client.createSession();
+
+  try {
+    await client.readFileStream(path, encoding);
+  } finally {
+    client.clearSession();
+  }
+}
+
 // Convenience function for quick file deletion
 export async function quickDeleteFile(
   path: string,