@cloudflare/sandbox 0.0.9 → 0.1.0

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.9",
+  "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.23"
+    "@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": [],