@cloudflare/sandbox 0.0.0-eb0ea62 → 0.0.0-f106fda

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 {
@@ -139,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;
@@ -203,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(
@@ -245,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;
   }
@@ -308,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;
@@ -317,8 +381,9 @@ export class HttpClient {
         body: JSON.stringify({
           args,
           command,
+          background,
           sessionId: targetSessionId,
-        }),
+        } as ExecuteRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -364,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;
@@ -373,6 +439,7 @@ export class HttpClient {
         body: JSON.stringify({
           args,
           command,
+          background,
           sessionId: targetSessionId,
         }),
         headers: {
@@ -420,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?.(
@@ -502,7 +568,7 @@ export class HttpClient {
           repoUrl,
           sessionId: targetSessionId,
           targetDir,
-        }),
+        } as GitCheckoutRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -593,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?.(
@@ -673,7 +738,7 @@ export class HttpClient {
           path,
           recursive,
           sessionId: targetSessionId,
-        }),
+        } as MkdirRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -714,7 +779,7 @@ export class HttpClient {
           path,
           recursive,
           sessionId: targetSessionId,
-        }),
+        } as MkdirRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -760,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?.(
@@ -840,7 +904,7 @@ export class HttpClient {
           encoding,
           path,
           sessionId: targetSessionId,
-        }),
+        } as WriteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -883,7 +947,7 @@ export class HttpClient {
           encoding,
           path,
           sessionId: targetSessionId,
-        }),
+        } as WriteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1006,7 +1070,7 @@ export class HttpClient {
           encoding,
           path,
           sessionId: targetSessionId,
-        }),
+        } as ReadFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1047,7 +1111,7 @@ export class HttpClient {
           encoding,
           path,
           sessionId: targetSessionId,
-        }),
+        } as ReadFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1102,10 +1166,8 @@ export class HttpClient {
 
                   case "command_complete":
                     console.log(
-                      `[HTTP Client] Read file completed: ${
-                        event.path
-                      }, Success: ${event.success}, Content length: ${
-                        event.content?.length || 0
+                      `[HTTP Client] Read file completed: ${event.path
+                      }, Success: ${event.success}, Content length: ${event.content?.length || 0
                       }`
                     );
                     this.options.onCommandComplete?.(
@@ -1162,7 +1224,7 @@ export class HttpClient {
         body: JSON.stringify({
           path,
           sessionId: targetSessionId,
-        }),
+        } as DeleteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1198,7 +1260,7 @@ export class HttpClient {
         body: JSON.stringify({
           path,
           sessionId: targetSessionId,
-        }),
+        } as DeleteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1308,7 +1370,7 @@ export class HttpClient {
           newPath,
           oldPath,
           sessionId: targetSessionId,
-        }),
+        } as RenameFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1349,7 +1411,7 @@ export class HttpClient {
           newPath,
           oldPath,
           sessionId: targetSessionId,
-        }),
+        } as RenameFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1462,7 +1524,7 @@ export class HttpClient {
           destinationPath,
           sessionId: targetSessionId,
           sourcePath,
-        }),
+        } as MoveFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1503,7 +1565,7 @@ export class HttpClient {
           destinationPath,
           sessionId: targetSessionId,
           sourcePath,
-        }),
+        } as MoveFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1606,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`, {

package/src/index.ts

@@ -1,129 +1,14 @@
-import { Container, getContainer } from "@cloudflare/containers";
-import { HttpClient } from "./client";
-
-export function getSandbox(ns: DurableObjectNamespace<Sandbox>, id: string) {
-  return getContainer(ns, id);
-}
-
-export class Sandbox<Env = unknown> extends Container<Env> {
-  defaultPort = 3000; // The default port for the container to listen on
-  sleepAfter = "3m"; // Sleep the sandbox if no requests are made in this timeframe
-
-  client: HttpClient = new HttpClient({
-    onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {
-      console.log(
-        `[Container] Command completed: ${command}, Success: ${success}, Exit code: ${exitCode}`
-      );
-    },
-    onCommandStart: (command, args) => {
-      console.log(`[Container] Command started: ${command} ${args.join(" ")}`);
-    },
-    onError: (error, command, args) => {
-      console.error(`[Container] Command error: ${error}`);
-    },
-    onOutput: (stream, data, command) => {
-      console.log(`[Container] [${stream}] ${data}`);
-    },
-    port: this.defaultPort,
-  });
-
-  envVars = {
-    MESSAGE: "I was passed in via the Sandbox class!",
-  };
-
-  override onStart() {
-    console.log("Sandbox successfully started");
-  }
-
-  override onStop() {
-    console.log("Sandbox successfully shut down");
-    if (this.client) {
-      this.client.clearSession();
-    }
-  }
-
-  override onError(error: unknown) {
-    console.log("Sandbox error:", error);
-  }
-
-  async exec(command: string, args: string[], options?: { stream?: boolean }) {
-    if (options?.stream) {
-      return this.client.executeStream(command, args);
-    }
-    return this.client.execute(command, args);
-  }
-
-  async gitCheckout(
-    repoUrl: string,
-    options: { branch?: string; targetDir?: string; stream?: boolean }
-  ) {
-    if (options?.stream) {
-      return this.client.gitCheckoutStream(
-        repoUrl,
-        options.branch,
-        options.targetDir
-      );
-    }
-    return this.client.gitCheckout(repoUrl, options.branch, options.targetDir);
-  }
-
-  async mkdir(
-    path: string,
-    options: { recursive?: boolean; stream?: boolean }
-  ) {
-    if (options?.stream) {
-      return this.client.mkdirStream(path, options.recursive);
-    }
-    return this.client.mkdir(path, options.recursive);
-  }
-
-  async writeFile(
-    path: string,
-    content: string,
-    options: { encoding?: string; stream?: boolean }
-  ) {
-    if (options?.stream) {
-      return this.client.writeFileStream(path, content, options.encoding);
-    }
-    return this.client.writeFile(path, content, options.encoding);
-  }
-
-  async deleteFile(path: string, options: { stream?: boolean }) {
-    if (options?.stream) {
-      return this.client.deleteFileStream(path);
-    }
-    return this.client.deleteFile(path);
-  }
-
-  async renameFile(
-    oldPath: string,
-    newPath: string,
-    options: { stream?: boolean }
-  ) {
-    if (options?.stream) {
-      return this.client.renameFileStream(oldPath, newPath);
-    }
-    return this.client.renameFile(oldPath, newPath);
-  }
-
-  async moveFile(
-    sourcePath: string,
-    destinationPath: string,
-    options: { stream?: boolean }
-  ) {
-    if (options?.stream) {
-      return this.client.moveFileStream(sourcePath, destinationPath);
-    }
-    return this.client.moveFile(sourcePath, destinationPath);
-  }
-
-  async readFile(
-    path: string,
-    options: { encoding?: string; stream?: boolean }
-  ) {
-    if (options?.stream) {
-      return this.client.readFileStream(path, options.encoding);
-    }
-    return this.client.readFile(path, options.encoding);
-  }
-}
+// Export types from client
+export type {
+  DeleteFileResponse, ExecuteResponse,
+  GitCheckoutResponse,
+  MkdirResponse, MoveFileResponse,
+  ReadFileResponse, RenameFileResponse, WriteFileResponse
+} from "./client";
+
+// Re-export request handler utilities
+export {
+  proxyToSandbox, type RouteInfo, type SandboxEnv
+} from './request-handler';
+
+export { getSandbox, Sandbox } from "./sandbox";

package/src/request-handler.ts

@@ -0,0 +1,95 @@
+import { getSandbox, type Sandbox } from "./sandbox";
+
+export interface SandboxEnv {
+  Sandbox: DurableObjectNamespace<Sandbox>;
+}
+
+export interface RouteInfo {
+  port: number;
+  sandboxId: string;
+  path: string;
+}
+
+export async function proxyToSandbox<E extends SandboxEnv>(
+  request: Request,
+  env: E
+): Promise<Response | null> {
+  try {
+    const url = new URL(request.url);
+    const routeInfo = extractSandboxRoute(url);
+
+    if (!routeInfo) {
+      return null; // Not a request to an exposed container port
+    }
+
+    const { sandboxId, port, path } = routeInfo;
+    const sandbox = getSandbox(env.Sandbox, sandboxId);
+
+    // Build proxy request with proper headers
+    let proxyUrl: string;
+
+    // Route based on the target port
+    if (port !== 3000) {
+      // Route directly to user's service on the specified port
+      proxyUrl = `http://localhost:${port}${path}${url.search}`;
+    } else {
+      // Port 3000 is our control plane - route normally
+      proxyUrl = `http://localhost:3000${path}${url.search}`;
+    }
+
+    const proxyRequest = new Request(proxyUrl, {
+      method: request.method,
+      headers: {
+        ...Object.fromEntries(request.headers),
+        'X-Original-URL': request.url,
+        'X-Forwarded-Host': url.hostname,
+        'X-Forwarded-Proto': url.protocol.replace(':', ''),
+        'X-Sandbox-Name': sandboxId, // Pass the friendly name
+      },
+      body: request.body,
+    });
+
+    return sandbox.containerFetch(proxyRequest, port);
+  } catch (error) {
+    console.error('[Sandbox] Proxy routing error:', error);
+    return new Response('Proxy routing error', { status: 500 });
+  }
+}
+
+function extractSandboxRoute(url: URL): RouteInfo | null {
+  // Production: subdomain pattern {port}-{sandboxId}.{domain}
+  const subdomainMatch = url.hostname.match(/^(\d+)-([a-zA-Z0-9-]+)\./);
+  if (subdomainMatch) {
+    return {
+      port: parseInt(subdomainMatch[1]),
+      sandboxId: subdomainMatch[2],
+      path: url.pathname,
+    };
+  }
+
+  // Development: path pattern /preview/{port}/{sandboxId}/*
+  if (isLocalhostPattern(url.hostname)) {
+    const pathMatch = url.pathname.match(/^\/preview\/(\d+)\/([^/]+)(\/.*)?$/);
+    if (pathMatch) {
+      return {
+        port: parseInt(pathMatch[1]),
+        sandboxId: pathMatch[2],
+        path: pathMatch[3] || "/",
+      };
+    }
+  }
+
+  return null;
+}
+
+export function isLocalhostPattern(hostname: string): boolean {
+  const hostPart = hostname.split(":")[0];
+  return (
+    hostPart === "localhost" ||
+    hostPart === "127.0.0.1" ||
+    hostPart === "::1" ||
+    hostPart === "[::1]" ||
+    hostPart === "0.0.0.0"
+  );
+}
+