@cloudflare/sandbox 0.0.0-46eb4e6 → 0.0.0-485cf61

package/dist/sse-parser.js

@@ -0,0 +1,11 @@
+import {
+  asyncIterableToSSEStream,
+  parseSSEStream,
+  responseToAsyncIterable
+} from "./chunk-NNGBXDMY.js";
+export {
+  asyncIterableToSSEStream,
+  parseSSEStream,
+  responseToAsyncIterable
+};
+//# sourceMappingURL=sse-parser.js.map

package/dist/sse-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@cloudflare/sandbox",
-  "version": "0.0.0-46eb4e6",
+  "version": "0.0.0-485cf61",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudflare/sandbox-sdk"
   },
   "description": "A sandboxed environment for running commands",
   "dependencies": {
-    "@cloudflare/containers": "^0.0.28"
+    "@cloudflare/containers": "^0.0.28",
+    "@repo/shared": "^0.0.0"
   },
   "tags": [
     "sandbox",
@@ -18,9 +19,14 @@
   ],
   "scripts": {
     "build": "rm -rf dist && tsup src/*.ts --outDir dist --dts --sourcemap --format esm",
-    "docker:local": "docker build . -t cloudflare/sandbox-test:$npm_package_version",
-    "docker:publish": "docker buildx build --platform linux/amd64,linux/arm64 -t cloudflare/sandbox:$npm_package_version --push .",
-    "docker:publish:beta": "docker buildx build --platform linux/amd64,linux/arm64 -t cloudflare/sandbox:$npm_package_version-beta --push ."
+    "check": "biome check && npm run typecheck",
+    "fix": "biome check --fix && npm run typecheck",
+    "typecheck": "tsc --noEmit",
+    "docker:local": "cd ../.. && docker build -f packages/sandbox/Dockerfile -t cloudflare/sandbox-test:$npm_package_version .",
+    "docker:publish": "cd ../.. && docker buildx build --platform linux/amd64,linux/arm64 -f packages/sandbox/Dockerfile -t cloudflare/sandbox:$npm_package_version --push .",
+    "docker:publish:beta": "cd ../.. && docker buildx build --platform linux/amd64,linux/arm64 -f packages/sandbox/Dockerfile -t cloudflare/sandbox:$npm_package_version-beta --push .",
+    "test": "vitest run --config vitest.config.ts",
+    "test:e2e": "cd ../.. && vitest run --config vitest.e2e.config.ts \"$@\""
   },
   "exports": {
     ".": {

package/src/clients/base-client.ts

@@ -0,0 +1,297 @@
+import type { ErrorResponse as NewErrorResponse } from '../errors';
+import { createErrorFromResponse, ErrorCode } from '../errors';
+import type {
+  HttpClientOptions,
+  ResponseHandler
+} from './types';
+
+// Container provisioning retry configuration
+const TIMEOUT_MS = 60_000;  // 60 seconds total timeout budget
+const MIN_TIME_FOR_RETRY_MS = 10_000;  // Need at least 10s remaining to retry (8s Container + 2s delay)
+
+/**
+ * Abstract base class providing common HTTP functionality for all domain clients
+ */
+export abstract class BaseHttpClient {
+  protected baseUrl: string;
+  protected options: HttpClientOptions;
+
+  constructor(options: HttpClientOptions = {}) {
+    this.options = {
+      ...options,
+    };
+    this.baseUrl = this.options.baseUrl!;
+    
+  }
+
+  /**
+   * Core HTTP request method with automatic retry for container provisioning delays
+   */
+  protected async doFetch(
+    path: string,
+    options?: RequestInit
+  ): Promise<Response> {
+    const startTime = Date.now();
+    let attempt = 0;
+
+    console.log(`[DEBUG] doFetch called for ${options?.method || 'GET'} ${path}`);
+
+    while (true) {
+      const response = await this.executeFetch(path, options);
+
+      console.log(`[DEBUG] Response status: ${response.status}`);
+
+      // Only retry container provisioning 503s, not user app 503s
+      if (response.status === 503) {
+        console.log('[DEBUG] Got 503 response, checking if container provisioning error...');
+
+        const isContainerProvisioning = await this.isContainerProvisioningError(response);
+
+        console.log('[DEBUG] isContainerProvisioning result:', isContainerProvisioning);
+
+        if (isContainerProvisioning) {
+          const elapsed = Date.now() - startTime;
+          const remaining = TIMEOUT_MS - elapsed;
+
+          console.log(`[DEBUG] Elapsed: ${elapsed}ms, Remaining: ${remaining}ms`);
+
+          // Check if we have enough time for another attempt
+          // (Need at least 10s: 8s for Container timeout + 2s delay)
+          if (remaining > MIN_TIME_FOR_RETRY_MS) {
+            // Exponential backoff: 2s, 4s, 8s, 16s (capped at 16s)
+            const delay = Math.min(2000 * 2 ** attempt, 16000);
+
+            console.log(
+              `[Sandbox SDK] Container provisioning in progress (attempt ${attempt + 1}), ` +
+              `retrying in ${delay}ms (${Math.floor(remaining / 1000)}s remaining)`
+            );
+
+            await new Promise(resolve => setTimeout(resolve, delay));
+            attempt++;
+            continue;
+          } else {
+            // Exhausted retries - log error and return response
+            // Let existing error handling convert to proper error
+            console.error(
+              `[Sandbox SDK] Container failed to provision after ${attempt + 1} attempts over 60s.`
+            );
+            return response;
+          }
+        } else {
+          console.log('[DEBUG] Not a container provisioning error, returning 503 immediately');
+        }
+      }
+
+      // Return response (success, user app error, or non-retryable error)
+      if (response.status !== 200) {
+        console.log(`[DEBUG] Returning response with status ${response.status}`);
+      }
+      return response;
+    }
+  }
+
+  /**
+   * Make a POST request with JSON body
+   */
+  protected async post<T>(
+    endpoint: string,
+    data: Record<string, any>,
+    responseHandler?: ResponseHandler<T>
+  ): Promise<T> {
+    const response = await this.doFetch(endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(data),
+    });
+
+    return this.handleResponse(response, responseHandler);
+  }
+
+  /**
+   * Make a GET request
+   */
+  protected async get<T>(
+    endpoint: string,
+    responseHandler?: ResponseHandler<T>
+  ): Promise<T> {
+    const response = await this.doFetch(endpoint, {
+      method: 'GET',
+    });
+
+    return this.handleResponse(response, responseHandler);
+  }
+
+  /**
+   * Make a DELETE request
+   */
+  protected async delete<T>(
+    endpoint: string,
+    responseHandler?: ResponseHandler<T>
+  ): Promise<T> {
+    const response = await this.doFetch(endpoint, {
+      method: 'DELETE',
+    });
+
+    return this.handleResponse(response, responseHandler);
+  }
+
+
+  /**
+   * Handle HTTP response with error checking and parsing
+   */
+  protected async handleResponse<T>(
+    response: Response,
+    customHandler?: ResponseHandler<T>
+  ): Promise<T> {
+    if (!response.ok) {
+      await this.handleErrorResponse(response);
+    }
+
+    if (customHandler) {
+      return customHandler(response);
+    }
+
+    try {
+      return await response.json();
+    } catch (error) {
+      // Handle malformed JSON responses gracefully
+      const errorResponse: NewErrorResponse = {
+        code: ErrorCode.INVALID_JSON_RESPONSE,
+        message: `Invalid JSON response: ${error instanceof Error ? error.message : 'Unknown parsing error'}`,
+        context: {},
+        httpStatus: response.status,
+        timestamp: new Date().toISOString()
+      };
+      throw createErrorFromResponse(errorResponse);
+    }
+  }
+
+  /**
+   * Handle error responses with consistent error throwing
+   */
+  protected async handleErrorResponse(response: Response): Promise<never> {
+    let errorData: NewErrorResponse;
+
+    try {
+      errorData = await response.json();
+    } catch {
+      // Fallback if response isn't JSON or parsing fails
+      errorData = {
+        code: ErrorCode.INTERNAL_ERROR,
+        message: `HTTP error! status: ${response.status}`,
+        context: { statusText: response.statusText },
+        httpStatus: response.status,
+        timestamp: new Date().toISOString()
+      };
+    }
+
+    // Convert ErrorResponse to appropriate Error class
+    const error = createErrorFromResponse(errorData);
+
+    // Call error callback if provided
+    this.options.onError?.(errorData.message, undefined);
+
+    throw error;
+  }
+
+
+
+  /**
+   * Create a streaming response handler for Server-Sent Events
+   */
+  protected async handleStreamResponse(
+    response: Response
+  ): Promise<ReadableStream<Uint8Array>> {
+    if (!response.ok) {
+      await this.handleErrorResponse(response);
+    }
+
+    if (!response.body) {
+      throw new Error('No response body for streaming');
+    }
+
+    return response.body;
+  }
+
+  /**
+   * Utility method to log successful operations
+   */
+  protected logSuccess(operation: string, details?: string): void {
+    const message = details
+      ? `[HTTP Client] ${operation}: ${details}`
+      : `[HTTP Client] ${operation} completed successfully`;
+    console.log(message);
+  }
+
+  /**
+   * Utility method to log errors
+   */
+  protected logError(operation: string, error: unknown): void {
+    console.error(`[HTTP Client] Error in ${operation}:`, error);
+  }
+
+  /**
+   * Check if 503 response is from container provisioning (retryable)
+   * vs user application (not retryable)
+   */
+  private async isContainerProvisioningError(response: Response): Promise<boolean> {
+    try {
+      // Clone response so we don't consume the original body
+      const cloned = response.clone();
+      const text = await cloned.text();
+
+      console.log('[DEBUG] 503 response body:', text.substring(0, 200));
+
+      // Container package returns specific message for provisioning errors
+      const isProvisioning = text.includes('There is no Container instance available');
+
+      console.log('[DEBUG] Is container provisioning error?', isProvisioning);
+
+      return isProvisioning;
+    } catch (error) {
+      console.error('[DEBUG] Error checking response body:', error);
+      // If we can't read the body, don't retry to be safe
+      return false;
+    }
+  }
+
+  private async executeFetch(path: string, options?: RequestInit): Promise<Response> {
+    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;
+    }
+  }
+}

package/src/clients/command-client.ts

@@ -0,0 +1,118 @@
+import { BaseHttpClient } from './base-client';
+import type { BaseApiResponse, HttpClientOptions, SessionRequest } from './types';
+
+/**
+ * Request interface for command execution
+ */
+export interface ExecuteRequest extends SessionRequest {
+  command: string;
+  timeoutMs?: number;
+}
+
+/**
+ * Response interface for command execution
+ */
+export interface ExecuteResponse extends BaseApiResponse {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  command: string;
+}
+
+/**
+ * Client for command execution operations
+ */
+export class CommandClient extends BaseHttpClient {
+  constructor(options: HttpClientOptions = {}) {
+    super(options);
+  }
+
+  /**
+   * Execute a command and return the complete result
+   * @param command - The command to execute
+   * @param sessionId - The session ID for this command execution
+   * @param timeoutMs - Optional timeout in milliseconds (unlimited by default)
+   */
+  async execute(
+    command: string,
+    sessionId: string,
+    timeoutMs?: number
+  ): Promise<ExecuteResponse> {
+    try {
+      const data: ExecuteRequest = {
+        command,
+        sessionId,
+        ...(timeoutMs !== undefined && { timeoutMs })
+      };
+
+      const response = await this.post<ExecuteResponse>(
+        '/api/execute',
+        data
+      );
+
+      this.logSuccess(
+        'Command executed',
+        `${command}, Success: ${response.success}`
+      );
+
+      // Call the callback if provided
+      this.options.onCommandComplete?.(
+        response.success,
+        response.exitCode,
+        response.stdout,
+        response.stderr,
+        response.command
+      );
+
+      return response;
+    } catch (error) {
+      this.logError('execute', error);
+
+      // Call error callback if provided
+      this.options.onError?.(
+        error instanceof Error ? error.message : String(error),
+        command
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * Execute a command and return a stream of events
+   * @param command - The command to execute
+   * @param sessionId - The session ID for this command execution
+   */
+  async executeStream(
+    command: string,
+    sessionId: string
+  ): Promise<ReadableStream<Uint8Array>> {
+    try {
+      const data = { command, sessionId };
+
+      const response = await this.doFetch('/api/execute/stream', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(data),
+      });
+
+      const stream = await this.handleStreamResponse(response);
+
+      this.logSuccess('Command stream started', command);
+
+      return stream;
+    } catch (error) {
+      this.logError('executeStream', error);
+
+      // Call error callback if provided
+      this.options.onError?.(
+        error instanceof Error ? error.message : String(error),
+        command
+      );
+
+      throw error;
+    }
+  }
+}