@cloudflare/sandbox 0.0.8 → 0.1.0

package/dist/index.js

@@ -1,111 +1,22 @@
 import {
-  HttpClient
-} from "./chunk-7WZJ3TRE.js";
-
-// src/index.ts
-import { Container, getContainer } from "@cloudflare/containers";
-function getSandbox(ns, id) {
-  return getContainer(ns, id);
-}
-var Sandbox = class extends Container {
-  defaultPort = 3e3;
-  // The default port for the container to listen on
-  sleepAfter = "3m";
-  // Sleep the sandbox if no requests are made in this timeframe
-  client;
-  constructor(ctx, env) {
-    super(ctx, env);
-    this.client = 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,
-      stub: this
-    });
-  }
-  envVars = {
-    MESSAGE: "I was passed in via the Sandbox class!"
-  };
-  onStart() {
-    console.log("Sandbox successfully started");
-  }
-  onStop() {
-    console.log("Sandbox successfully shut down");
-    if (this.client) {
-      this.client.clearSession();
-    }
-  }
-  onError(error) {
-    console.log("Sandbox error:", error);
-  }
-  async exec(command, args, options) {
-    if (options?.stream) {
-      return this.client.executeStream(command, args);
-    }
-    return this.client.execute(command, args);
-  }
-  async gitCheckout(repoUrl, options) {
-    if (options?.stream) {
-      return this.client.gitCheckoutStream(
-        repoUrl,
-        options.branch,
-        options.targetDir
-      );
-    }
-    return this.client.gitCheckout(repoUrl, options.branch, options.targetDir);
-  }
-  async mkdir(path, options = {}) {
-    if (options?.stream) {
-      return this.client.mkdirStream(path, options.recursive);
-    }
-    return this.client.mkdir(path, options.recursive);
-  }
-  async writeFile(path, content, options = {}) {
-    if (options?.stream) {
-      return this.client.writeFileStream(path, content, options.encoding);
-    }
-    return this.client.writeFile(path, content, options.encoding);
-  }
-  async deleteFile(path, options = {}) {
-    if (options?.stream) {
-      return this.client.deleteFileStream(path);
-    }
-    return this.client.deleteFile(path);
-  }
-  async renameFile(oldPath, newPath, options = {}) {
-    if (options?.stream) {
-      return this.client.renameFileStream(oldPath, newPath);
-    }
-    return this.client.renameFile(oldPath, newPath);
-  }
-  async moveFile(sourcePath, destinationPath, options = {}) {
-    if (options?.stream) {
-      return this.client.moveFileStream(sourcePath, destinationPath);
-    }
-    return this.client.moveFile(sourcePath, destinationPath);
-  }
-  async readFile(path, options = {}) {
-    if (options?.stream) {
-      return this.client.readFileStream(path, options.encoding);
-    }
-    return this.client.readFile(path, options.encoding);
-  }
-};
+  Sandbox,
+  getSandbox,
+  proxyToSandbox
+} from "./chunk-ISFOIYQC.js";
+import "./chunk-G4XT4SP7.js";
+import "./chunk-6UAWTJ5S.js";
+import {
+  asyncIterableToSSEStream,
+  parseSSEStream,
+  responseToAsyncIterable
+} from "./chunk-NNGBXDMY.js";
+import "./chunk-6THNBO4S.js";
 export {
   Sandbox,
-  getSandbox
+  asyncIterableToSSEStream,
+  getSandbox,
+  parseSSEStream,
+  proxyToSandbox,
+  responseToAsyncIterable
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { Container, getContainer } from \"@cloudflare/containers\";\nimport { HttpClient } from \"./client\";\n\nexport function getSandbox(ns: DurableObjectNamespace<Sandbox>, id: string) {\n  return getContainer(ns, id);\n}\n\nexport class Sandbox<Env = unknown> extends Container<Env> {\n  defaultPort = 3000; // The default port for the container to listen on\n  sleepAfter = \"3m\"; // Sleep the sandbox if no requests are made in this timeframe\n  client: HttpClient;\n\n  constructor(ctx: DurableObjectState, env: Env) {\n    super(ctx, env);\n    this.client = new HttpClient({\n      onCommandComplete: (success, exitCode, stdout, stderr, command, args) => {\n        console.log(\n          `[Container] Command completed: ${command}, Success: ${success}, Exit code: ${exitCode}`\n        );\n      },\n      onCommandStart: (command, args) => {\n        console.log(\n          `[Container] Command started: ${command} ${args.join(\" \")}`\n        );\n      },\n      onError: (error, command, args) => {\n        console.error(`[Container] Command error: ${error}`);\n      },\n      onOutput: (stream, data, command) => {\n        console.log(`[Container] [${stream}] ${data}`);\n      },\n      port: this.defaultPort,\n      stub: this,\n    });\n  }\n\n  envVars = {\n    MESSAGE: \"I was passed in via the Sandbox class!\",\n  };\n\n  override onStart() {\n    console.log(\"Sandbox successfully started\");\n  }\n\n  override onStop() {\n    console.log(\"Sandbox successfully shut down\");\n    if (this.client) {\n      this.client.clearSession();\n    }\n  }\n\n  override onError(error: unknown) {\n    console.log(\"Sandbox error:\", error);\n  }\n\n  async exec(command: string, args: string[], options?: { stream?: boolean }) {\n    if (options?.stream) {\n      return this.client.executeStream(command, args);\n    }\n    return this.client.execute(command, args);\n  }\n\n  async gitCheckout(\n    repoUrl: string,\n    options: { branch?: string; targetDir?: string; stream?: boolean }\n  ) {\n    if (options?.stream) {\n      return this.client.gitCheckoutStream(\n        repoUrl,\n        options.branch,\n        options.targetDir\n      );\n    }\n    return this.client.gitCheckout(repoUrl, options.branch, options.targetDir);\n  }\n\n  async mkdir(\n    path: string,\n    options: { recursive?: boolean; stream?: boolean } = {}\n  ) {\n    if (options?.stream) {\n      return this.client.mkdirStream(path, options.recursive);\n    }\n    return this.client.mkdir(path, options.recursive);\n  }\n\n  async writeFile(\n    path: string,\n    content: string,\n    options: { encoding?: string; stream?: boolean } = {}\n  ) {\n    if (options?.stream) {\n      return this.client.writeFileStream(path, content, options.encoding);\n    }\n    return this.client.writeFile(path, content, options.encoding);\n  }\n\n  async deleteFile(path: string, options: { stream?: boolean } = {}) {\n    if (options?.stream) {\n      return this.client.deleteFileStream(path);\n    }\n    return this.client.deleteFile(path);\n  }\n\n  async renameFile(\n    oldPath: string,\n    newPath: string,\n    options: { stream?: boolean } = {}\n  ) {\n    if (options?.stream) {\n      return this.client.renameFileStream(oldPath, newPath);\n    }\n    return this.client.renameFile(oldPath, newPath);\n  }\n\n  async moveFile(\n    sourcePath: string,\n    destinationPath: string,\n    options: { stream?: boolean } = {}\n  ) {\n    if (options?.stream) {\n      return this.client.moveFileStream(sourcePath, destinationPath);\n    }\n    return this.client.moveFile(sourcePath, destinationPath);\n  }\n\n  async readFile(\n    path: string,\n    options: { encoding?: string; stream?: boolean } = {}\n  ) {\n    if (options?.stream) {\n      return this.client.readFileStream(path, options.encoding);\n    }\n    return this.client.readFile(path, options.encoding);\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/request-handler.d.ts

@@ -0,0 +1,16 @@
+import { S as Sandbox } from './client-Da-mLX4p.js';
+import '@cloudflare/containers';
+import './types.js';
+
+interface SandboxEnv {
+    Sandbox: DurableObjectNamespace<Sandbox>;
+}
+interface RouteInfo {
+    port: number;
+    sandboxId: string;
+    path: string;
+}
+declare function proxyToSandbox<E extends SandboxEnv>(request: Request, env: E): Promise<Response | null>;
+declare function isLocalhostPattern(hostname: string): boolean;
+
+export { type RouteInfo, type SandboxEnv, isLocalhostPattern, proxyToSandbox };

package/dist/request-handler.js

@@ -0,0 +1,12 @@
+import {
+  isLocalhostPattern,
+  proxyToSandbox
+} from "./chunk-ISFOIYQC.js";
+import "./chunk-G4XT4SP7.js";
+import "./chunk-6UAWTJ5S.js";
+import "./chunk-6THNBO4S.js";
+export {
+  isLocalhostPattern,
+  proxyToSandbox
+};
+//# sourceMappingURL=request-handler.js.map

package/dist/request-handler.js.map

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

package/dist/sandbox.d.ts

@@ -0,0 +1,3 @@
+export { S as Sandbox, g as getSandbox } from './client-Da-mLX4p.js';
+import '@cloudflare/containers';
+import './types.js';

package/dist/sandbox.js

@@ -0,0 +1,12 @@
+import {
+  Sandbox,
+  getSandbox
+} from "./chunk-ISFOIYQC.js";
+import "./chunk-G4XT4SP7.js";
+import "./chunk-6UAWTJ5S.js";
+import "./chunk-6THNBO4S.js";
+export {
+  Sandbox,
+  getSandbox
+};
+//# sourceMappingURL=sandbox.js.map

package/dist/sandbox.js.map

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

package/dist/security.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Security utilities for URL construction and input validation
+ *
+ * This module contains critical security functions to prevent:
+ * - URL injection attacks
+ * - SSRF (Server-Side Request Forgery) attacks
+ * - DNS rebinding attacks
+ * - Host header injection
+ * - Open redirect vulnerabilities
+ */
+declare class SecurityError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/**
+ * Validates port numbers for sandbox services
+ * Only allows non-system ports to prevent conflicts and security issues
+ */
+declare function validatePort(port: number): boolean;
+/**
+ * Sanitizes and validates sandbox IDs for DNS compliance and security
+ * Only enforces critical requirements - allows maximum developer flexibility
+ */
+declare function sanitizeSandboxId(id: string): string;
+/**
+ * Logs security events for monitoring
+ */
+declare function logSecurityEvent(event: string, details: Record<string, any>, severity?: 'low' | 'medium' | 'high' | 'critical'): void;
+
+export { SecurityError, logSecurityEvent, sanitizeSandboxId, validatePort };

package/dist/security.js

@@ -0,0 +1,13 @@
+import {
+  SecurityError,
+  logSecurityEvent,
+  sanitizeSandboxId,
+  validatePort
+} from "./chunk-6UAWTJ5S.js";
+export {
+  SecurityError,
+  logSecurityEvent,
+  sanitizeSandboxId,
+  validatePort
+};
+//# sourceMappingURL=security.js.map

package/dist/security.js.map

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

package/dist/sse-parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Server-Sent Events (SSE) parser for streaming responses
+ * Converts ReadableStream<Uint8Array> to typed AsyncIterable<T>
+ */
+/**
+ * Parse a ReadableStream of SSE events into typed AsyncIterable
+ * @param stream - The ReadableStream from fetch response
+ * @param signal - Optional AbortSignal for cancellation
+ */
+declare function parseSSEStream<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<T>;
+/**
+ * Helper to convert a Response with SSE stream directly to AsyncIterable
+ * @param response - Response object with SSE stream
+ * @param signal - Optional AbortSignal for cancellation
+ */
+declare function responseToAsyncIterable<T>(response: Response, signal?: AbortSignal): AsyncIterable<T>;
+/**
+ * Create an SSE-formatted ReadableStream from an AsyncIterable
+ * (Useful for Worker endpoints that need to forward AsyncIterable as SSE)
+ * @param events - AsyncIterable of events
+ * @param options - Stream options
+ */
+declare function asyncIterableToSSEStream<T>(events: AsyncIterable<T>, options?: {
+    signal?: AbortSignal;
+    serialize?: (event: T) => string;
+}): ReadableStream<Uint8Array>;
+
+export { asyncIterableToSSEStream, parseSSEStream, responseToAsyncIterable };

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/dist/types.d.ts

@@ -0,0 +1,284 @@
+interface BaseExecOptions {
+    /**
+     * Session ID for grouping related commands
+     */
+    sessionId?: string;
+    /**
+     * Maximum execution time in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Environment variables for the command
+     */
+    env?: Record<string, string>;
+    /**
+     * Working directory for command execution
+     */
+    cwd?: string;
+    /**
+     * Text encoding for output (default: 'utf8')
+     */
+    encoding?: string;
+}
+interface ExecOptions extends BaseExecOptions {
+    /**
+     * Enable real-time output streaming via callbacks
+     */
+    stream?: boolean;
+    /**
+     * Callback for real-time output data
+     */
+    onOutput?: (stream: 'stdout' | 'stderr', data: string) => void;
+    /**
+     * Callback when command completes (only when stream: true)
+     */
+    onComplete?: (result: ExecResult) => void;
+    /**
+     * Callback for execution errors
+     */
+    onError?: (error: Error) => void;
+    /**
+     * AbortSignal for cancelling execution
+     */
+    signal?: AbortSignal;
+}
+interface ExecResult {
+    /**
+     * Whether the command succeeded (exitCode === 0)
+     */
+    success: boolean;
+    /**
+     * Process exit code
+     */
+    exitCode: number;
+    /**
+     * Standard output content
+     */
+    stdout: string;
+    /**
+     * Standard error content
+     */
+    stderr: string;
+    /**
+     * Command that was executed
+     */
+    command: string;
+    /**
+     * Execution duration in milliseconds
+     */
+    duration: number;
+    /**
+     * ISO timestamp when command started
+     */
+    timestamp: string;
+    /**
+     * Session ID if provided
+     */
+    sessionId?: string;
+}
+interface ProcessOptions extends BaseExecOptions {
+    /**
+     * Custom process ID for later reference
+     * If not provided, a UUID will be generated
+     */
+    processId?: string;
+    /**
+     * Automatically cleanup process record after exit (default: true)
+     */
+    autoCleanup?: boolean;
+    /**
+     * Callback when process exits
+     */
+    onExit?: (code: number | null) => void;
+    /**
+     * Callback for real-time output (background processes)
+     */
+    onOutput?: (stream: 'stdout' | 'stderr', data: string) => void;
+    /**
+     * Callback when process starts successfully
+     */
+    onStart?: (process: Process) => void;
+    /**
+     * Callback for process errors
+     */
+    onError?: (error: Error) => void;
+}
+type ProcessStatus = 'starting' | 'running' | 'completed' | 'failed' | 'killed' | 'error';
+interface Process {
+    /**
+     * Unique process identifier
+     */
+    readonly id: string;
+    /**
+     * System process ID (if available and running)
+     */
+    readonly pid?: number;
+    /**
+     * Command that was executed
+     */
+    readonly command: string;
+    /**
+     * Current process status
+     */
+    readonly status: ProcessStatus;
+    /**
+     * When the process was started
+     */
+    readonly startTime: Date;
+    /**
+     * When the process ended (if completed)
+     */
+    readonly endTime?: Date;
+    /**
+     * Process exit code (if completed)
+     */
+    readonly exitCode?: number;
+    /**
+     * Session ID if provided
+     */
+    readonly sessionId?: string;
+    /**
+     * Kill the process
+     */
+    kill(signal?: string): Promise<void>;
+    /**
+     * Get current process status (refreshed)
+     */
+    getStatus(): Promise<ProcessStatus>;
+    /**
+     * Get accumulated logs
+     */
+    getLogs(): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}
+interface ExecEvent {
+    type: 'start' | 'stdout' | 'stderr' | 'complete' | 'error';
+    timestamp: string;
+    data?: string;
+    command?: string;
+    exitCode?: number;
+    result?: ExecResult;
+    error?: string;
+    sessionId?: string;
+}
+interface LogEvent {
+    type: 'stdout' | 'stderr' | 'exit' | 'error';
+    timestamp: string;
+    data: string;
+    processId: string;
+    sessionId?: string;
+    exitCode?: number;
+}
+interface StreamOptions extends BaseExecOptions {
+    /**
+     * Buffer size for streaming output
+     */
+    bufferSize?: number;
+    /**
+     * AbortSignal for cancelling stream
+     */
+    signal?: AbortSignal;
+}
+declare class SandboxError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+declare class ProcessNotFoundError extends SandboxError {
+    constructor(processId: string);
+}
+declare class ProcessAlreadyExistsError extends SandboxError {
+    constructor(processId: string);
+}
+declare class ExecutionTimeoutError extends SandboxError {
+    constructor(timeout: number);
+}
+interface ProcessRecord {
+    id: string;
+    pid?: number;
+    command: string;
+    status: ProcessStatus;
+    startTime: Date;
+    endTime?: Date;
+    exitCode?: number;
+    sessionId?: string;
+    childProcess?: any;
+    stdout: string;
+    stderr: string;
+    outputListeners: Set<(stream: 'stdout' | 'stderr', data: string) => void>;
+    statusListeners: Set<(status: ProcessStatus) => void>;
+}
+interface StartProcessRequest {
+    command: string;
+    options?: {
+        processId?: string;
+        sessionId?: string;
+        timeout?: number;
+        env?: Record<string, string>;
+        cwd?: string;
+        encoding?: string;
+        autoCleanup?: boolean;
+    };
+}
+interface StartProcessResponse {
+    process: {
+        id: string;
+        pid?: number;
+        command: string;
+        status: ProcessStatus;
+        startTime: string;
+        sessionId?: string;
+    };
+}
+interface ListProcessesResponse {
+    processes: Array<{
+        id: string;
+        pid?: number;
+        command: string;
+        status: ProcessStatus;
+        startTime: string;
+        endTime?: string;
+        exitCode?: number;
+        sessionId?: string;
+    }>;
+}
+interface GetProcessResponse {
+    process: {
+        id: string;
+        pid?: number;
+        command: string;
+        status: ProcessStatus;
+        startTime: string;
+        endTime?: string;
+        exitCode?: number;
+        sessionId?: string;
+    } | null;
+}
+interface GetProcessLogsResponse {
+    stdout: string;
+    stderr: string;
+    processId: string;
+}
+interface ISandbox {
+    exec(command: string, options?: ExecOptions): Promise<ExecResult>;
+    startProcess(command: string, options?: ProcessOptions): Promise<Process>;
+    listProcesses(): Promise<Process[]>;
+    getProcess(id: string): Promise<Process | null>;
+    killProcess(id: string, signal?: string): Promise<void>;
+    killAllProcesses(): Promise<number>;
+    execStream(command: string, options?: StreamOptions): Promise<ReadableStream<Uint8Array>>;
+    streamProcessLogs(processId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array>>;
+    cleanupCompletedProcesses(): Promise<number>;
+    getProcessLogs(id: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}
+declare function isExecResult(value: any): value is ExecResult;
+declare function isProcess(value: any): value is Process;
+declare function isProcessStatus(value: string): value is ProcessStatus;
+
+export { type BaseExecOptions, type ExecEvent, type ExecOptions, type ExecResult, ExecutionTimeoutError, type GetProcessLogsResponse, type GetProcessResponse, type ISandbox, type ListProcessesResponse, type LogEvent, type Process, ProcessAlreadyExistsError, ProcessNotFoundError, type ProcessOptions, type ProcessRecord, type ProcessStatus, SandboxError, type StartProcessRequest, type StartProcessResponse, type StreamOptions, isExecResult, isProcess, isProcessStatus };

package/dist/types.js

@@ -0,0 +1,19 @@
+import {
+  ExecutionTimeoutError,
+  ProcessAlreadyExistsError,
+  ProcessNotFoundError,
+  SandboxError,
+  isExecResult,
+  isProcess,
+  isProcessStatus
+} from "./chunk-6THNBO4S.js";
+export {
+  ExecutionTimeoutError,
+  ProcessAlreadyExistsError,
+  ProcessNotFoundError,
+  SandboxError,
+  isExecResult,
+  isProcess,
+  isProcessStatus
+};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

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

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cloudflare/sandbox",
-  "version": "0.0.8",
+  "version": "0.1.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudflare/sandbox-sdk"
   },
   "description": "A sandboxed environment for running commands",
   "dependencies": {
-    "@cloudflare/containers": "^0.0.19"
+    "@cloudflare/containers": "^0.0.24"
   },
   "tags": [
     "sandbox",
@@ -26,11 +26,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js"
-    },
-    "./client": {
-      "types": "./dist/client.d.ts",
-      "import": "./dist/client.js",
-      "require": "./dist/client.js"
     }
   },
   "keywords": [],