computesdk 1.0.2 → 2.0.0

package/dist/index.d.mts

@@ -10,7 +10,7 @@ type Runtime = 'node' | 'python';
 /**
  * Supported provider types
  */
-type ProviderType = 'e2b' | 'vercel' | 'cloudflare' | 'fly' | 'auto';
+type ProviderType = 'e2b' | 'vercel' | 'daytona' | 'auto';
 /**
  * Sandbox status types
  */
@@ -80,9 +80,63 @@ interface SandboxConfig {
     timeout?: number;
 }
 /**
- * Provider specification that all providers must implement
+ * File system entry information
+ */
+interface FileEntry {
+    /** File/directory name */
+    name: string;
+    /** Full path to the entry */
+    path: string;
+    /** Whether this is a directory */
+    isDirectory: boolean;
+    /** File size in bytes (0 for directories) */
+    size: number;
+    /** Last modified timestamp */
+    lastModified: Date;
+}
+/**
+ * Basic terminal session information
+ */
+interface TerminalSession {
+    /** Terminal process ID */
+    pid: number;
+    /** Terminal command */
+    command: string;
+    /** Terminal status */
+    status: 'running' | 'exited';
+    /** Exit code (if exited) */
+    exitCode?: number;
+}
+/**
+ * File system interface for sandbox operations
+ */
+interface SandboxFileSystem {
+    /** Read file contents */
+    readFile(path: string): Promise<string>;
+    /** Write file contents */
+    writeFile(path: string, content: string): Promise<void>;
+    /** Create directory */
+    mkdir(path: string): Promise<void>;
+    /** List directory contents */
+    readdir(path: string): Promise<FileEntry[]>;
+    /** Check if file/directory exists */
+    exists(path: string): Promise<boolean>;
+    /** Remove file or directory */
+    remove(path: string): Promise<void>;
+}
+/**
+ * Terminal operations interface for managing terminal sessions in a sandbox
  */
-interface ComputeSpecification {
+interface SandboxTerminal {
+    /** Create a new interactive terminal session */
+    create(options?: TerminalCreateOptions): Promise<InteractiveTerminalSession>;
+    /** List active terminal sessions */
+    list(): Promise<InteractiveTerminalSession[]>;
+}
+/**
+ * Base provider specification that all providers must implement
+ */
+interface BaseComputeSpecification {
     /** Version of the specification */
     specificationVersion: 'v1';
     /** Provider identifier */
@@ -91,26 +145,80 @@ interface ComputeSpecification {
     sandboxId: string;
     /** Execute code in the sandbox */
     doExecute(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    /** Execute code in a runtime environment */
+    runCode(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    /** Execute shell commands */
+    runCommand(command: string, args?: string[]): Promise<ExecutionResult>;
     /** Kill the sandbox */
     doKill(): Promise<void>;
     /** Get information about the sandbox */
     doGetInfo(): Promise<SandboxInfo>;
 }
 /**
- * The core compute sandbox interface that all providers expose
+ * Provider specification with filesystem support
+ */
+interface FilesystemComputeSpecification extends BaseComputeSpecification {
+    /** File system operations */
+    readonly filesystem: SandboxFileSystem;
+}
+/**
+ * Provider specification with terminal support
  */
-interface ComputeSandbox {
+interface TerminalComputeSpecification extends BaseComputeSpecification {
+    /** Terminal operations */
+    readonly terminal: SandboxTerminal;
+}
+/**
+ * Provider specification with full filesystem and terminal support
+ */
+interface FullComputeSpecification extends FilesystemComputeSpecification, TerminalComputeSpecification {
+}
+/**
+ * Union type for all possible provider specifications
+ */
+type ComputeSpecification = BaseComputeSpecification | FilesystemComputeSpecification | TerminalComputeSpecification | FullComputeSpecification;
+/**
+ * Base compute sandbox interface that all providers expose
+ */
+interface BaseComputeSandbox {
     /** Provider identifier */
     provider: string;
     /** Sandbox identifier */
     sandboxId: string;
     /** Execute code in the sandbox */
     execute(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    /** Execute code in a runtime environment */
+    runCode(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    /** Execute shell commands */
+    runCommand(command: string, args?: string[]): Promise<ExecutionResult>;
     /** Kill the sandbox */
     kill(): Promise<void>;
     /** Get information about the sandbox */
     getInfo(): Promise<SandboxInfo>;
 }
+/**
+ * Compute sandbox with filesystem support
+ */
+interface FilesystemComputeSandbox extends BaseComputeSandbox {
+    /** File system operations */
+    readonly filesystem: SandboxFileSystem;
+}
+/**
+ * Compute sandbox with terminal support
+ */
+interface TerminalComputeSandbox extends BaseComputeSandbox {
+    /** Terminal operations */
+    readonly terminal: SandboxTerminal;
+}
+/**
+ * Compute sandbox with full filesystem and terminal support
+ */
+interface FullComputeSandbox extends FilesystemComputeSandbox, TerminalComputeSandbox {
+}
+/**
+ * Union type for all possible compute sandbox types
+ */
+type ComputeSandbox = BaseComputeSandbox | FilesystemComputeSandbox | TerminalComputeSandbox | FullComputeSandbox;
 /**
  * Parameters for the executeSandbox function
  */
@@ -130,13 +238,61 @@ interface ProviderRegistry {
     sandbox(id: string): ComputeSandbox;
 }
 /**
- * Provider factory function type
+ * Provider factory function type for base providers
  */
-type ProviderFactory = (config?: any) => ComputeSandbox;
+type BaseProviderFactory = (config?: any) => BaseComputeSandbox;
+/**
+ * Provider factory function type for filesystem providers
+ */
+type FilesystemProviderFactory = (config?: any) => FilesystemComputeSandbox;
+/**
+ * Provider factory function type for terminal providers
+ */
+type TerminalProviderFactory = (config?: any) => TerminalComputeSandbox;
+/**
+ * Provider factory function type for full-featured providers
+ */
+type FullProviderFactory = (config?: any) => FullComputeSandbox;
+/**
+ * Union type for all provider factory types
+ */
+type ProviderFactory = BaseProviderFactory | FilesystemProviderFactory | TerminalProviderFactory | FullProviderFactory;
 /**
  * Provider registry map type
  */
 type ProviderMap = Record<string, ProviderFactory>;
+/**
+ * Terminal session with PTY (pseudo-terminal) support for interactive use
+ */
+interface InteractiveTerminalSession extends TerminalSession {
+    /** Terminal columns */
+    cols: number;
+    /** Terminal rows */
+    rows: number;
+    /** Data stream handler */
+    onData?: (data: Uint8Array) => void;
+    /** Exit handler */
+    onExit?: (exitCode: number) => void;
+    /** Write data to this terminal session */
+    write(data: Uint8Array | string): Promise<void>;
+    /** Resize this terminal session */
+    resize(cols: number, rows: number): Promise<void>;
+    /** Kill this terminal session */
+    kill(): Promise<void>;
+}
+/**
+ * Terminal creation options
+ */
+interface TerminalCreateOptions {
+    /** Command to run (defaults to shell) */
+    command?: string;
+    /** Terminal columns */
+    cols?: number;
+    /** Terminal rows */
+    rows?: number;
+    /** Environment variables */
+    env?: Record<string, string>;
+}
 
 /**
  * ComputeSDK Error Handling
@@ -293,15 +449,8 @@ declare const DEFAULT_TIMEOUT = 300000;
 declare const ENV_KEYS: {
     E2B: string;
     VERCEL: string;
-    CLOUDFLARE: string;
-    FLY: string;
+    DAYTONA: string;
 };
-/**
- * Detect if running in Cloudflare Workers environment
- *
- * @returns True if running in Cloudflare Workers
- */
-declare function isCloudflareWorkers(): boolean;
 /**
  * Detect available providers based on environment variables
  *
@@ -352,10 +501,53 @@ declare function normalizeSandboxConfig(config?: Partial<SandboxConfig>): Sandbo
  * Execute code in a sandbox
  */
 declare function executeSandbox(params: ExecuteSandboxParams): Promise<ExecutionResult>;
+/**
+ * Parameters for the runCode function
+ */
+interface RunCodeParams {
+    /** Sandbox to execute in */
+    sandbox: ComputeSandbox;
+    /** Code to execute */
+    code: string;
+    /** Runtime to use */
+    runtime?: Runtime;
+}
+/**
+ * Execute code in a runtime environment
+ */
+declare function runCode(params: RunCodeParams): Promise<ExecutionResult>;
+/**
+ * Parameters for the runCommand function
+ */
+interface RunCommandParams {
+    /** Sandbox to execute in */
+    sandbox: ComputeSandbox;
+    /** Command to execute */
+    command: string;
+    /** Command arguments */
+    args?: string[];
+}
+/**
+ * Execute shell commands
+ */
+declare function runCommand(params: RunCommandParams): Promise<ExecutionResult>;
+/**
+ * Options for retry function
+ */
+interface RetryOptions {
+    /** Maximum number of attempts (default: 3) */
+    maxAttempts?: number;
+    /** Base delay in milliseconds (default: 1000) */
+    delay?: number;
+    /** Backoff multiplier (default: 2) */
+    backoff?: number;
+    /** Callback called on each retry attempt */
+    onRetry?: (error: Error, attempt: number) => void;
+}
 /**
  * Retry function with exponential backoff
  */
-declare function retry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
 
 /**
  * ComputeSDK Provider Registry
@@ -371,19 +563,12 @@ declare function retry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?:
  */
 declare function createComputeRegistry(providers: ProviderMap): ProviderRegistry;
 
-/**
- * ComputeSDK Base Provider
- *
- * This file contains the base provider implementation that all
- * specific provider implementations extend.
- */
-
 /**
  * Base implementation of the ComputeSandbox interface
  *
  * Provides common functionality and wraps provider-specific implementations.
  */
-declare abstract class BaseProvider implements ComputeSandbox, ComputeSpecification {
+declare abstract class BaseProvider implements BaseComputeSandbox, BaseComputeSpecification {
     /** Specification version */
     readonly specificationVersion = "v1";
     /** Provider identifier */
@@ -419,6 +604,22 @@ declare abstract class BaseProvider implements ComputeSandbox, ComputeSpecificat
      * @returns Sandbox information
      */
     getInfo(): Promise<SandboxInfo>;
+    /**
+     * Execute code in a runtime environment
+     *
+     * @param code Code to execute
+     * @param runtime Optional runtime to use
+     * @returns Execution result
+     */
+    runCode(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    /**
+     * Execute shell commands
+     *
+     * @param command Command to execute
+     * @param args Command arguments
+     * @returns Execution result
+     */
+    runCommand(command: string, args?: string[]): Promise<ExecutionResult>;
     /**
      * Provider-specific implementation of code execution
      *
@@ -439,6 +640,54 @@ declare abstract class BaseProvider implements ComputeSandbox, ComputeSpecificat
      * @returns Sandbox information
      */
     abstract doGetInfo(): Promise<SandboxInfo>;
+    /**
+     * Provider-specific implementation of code execution (optional)
+     *
+     * @param code Code to execute
+     * @param runtime Optional runtime to use
+     * @returns Execution result
+     */
+    doRunCode?(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    /**
+     * Provider-specific implementation of command execution (optional)
+     *
+     * @param command Command to execute
+     * @param args Command arguments
+     * @returns Execution result
+     */
+    doRunCommand?(command: string, args: string[]): Promise<ExecutionResult>;
+}
+/**
+ * Helper class for implementing FileSystem with error handling
+ */
+declare abstract class BaseFileSystem implements SandboxFileSystem {
+    protected provider: string;
+    protected sandboxId: string;
+    constructor(provider: string, sandboxId: string);
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    readdir(path: string): Promise<FileEntry[]>;
+    exists(path: string): Promise<boolean>;
+    remove(path: string): Promise<void>;
+    protected abstract doReadFile(path: string): Promise<string>;
+    protected abstract doWriteFile(path: string, content: string): Promise<void>;
+    protected abstract doMkdir(path: string): Promise<void>;
+    protected abstract doReaddir(path: string): Promise<FileEntry[]>;
+    protected abstract doExists(path: string): Promise<boolean>;
+    protected abstract doRemove(path: string): Promise<void>;
+}
+/**
+ * Helper class for implementing Terminal with error handling
+ */
+declare abstract class BaseTerminal implements SandboxTerminal {
+    protected provider: string;
+    protected sandboxId: string;
+    constructor(provider: string, sandboxId: string);
+    create(options?: TerminalCreateOptions): Promise<InteractiveTerminalSession>;
+    list(): Promise<InteractiveTerminalSession[]>;
+    protected abstract doCreate(options?: TerminalCreateOptions): Promise<InteractiveTerminalSession>;
+    protected abstract doList(): Promise<InteractiveTerminalSession[]>;
 }
 
 declare class ComputeSDK {
@@ -464,4 +713,4 @@ declare class ComputeSDK {
  * isolated sandboxed environments across multiple cloud providers.
  */
 
-export { AuthenticationError, BaseProvider, ComputeError, ComputeSDK, type ComputeSandbox, type ComputeSpecification, ConfigurationError, type ContainerConfig, DEFAULT_TIMEOUT, ENV_KEYS, type ExecuteSandboxParams, ExecutionError, type ExecutionResult, ProviderError, type ProviderFactory, type ProviderMap, type ProviderRegistry, type ProviderType, ProviderUnavailableError, type Runtime, type SandboxConfig, type SandboxInfo, type SandboxStatus, TimeoutError, autoSelectProvider, createComputeRegistry, ComputeSDK as default, detectAvailableProviders, executeSandbox, getDefaultRuntime, isCloudflareWorkers, normalizeContainerConfig, normalizeSandboxConfig, retry, validateProviderApiKey };
+export { AuthenticationError, type BaseComputeSandbox, type BaseComputeSpecification, BaseFileSystem, BaseProvider, type BaseProviderFactory, BaseTerminal, ComputeError, ComputeSDK, type ComputeSandbox, type ComputeSpecification, ConfigurationError, type ContainerConfig, DEFAULT_TIMEOUT, ENV_KEYS, type ExecuteSandboxParams, ExecutionError, type ExecutionResult, type FileEntry, type FilesystemComputeSandbox, type FilesystemComputeSpecification, type FilesystemProviderFactory, type FullComputeSandbox, type FullComputeSpecification, type FullProviderFactory, type InteractiveTerminalSession, ProviderError, type ProviderFactory, type ProviderMap, type ProviderRegistry, type ProviderType, ProviderUnavailableError, type Runtime, type SandboxConfig, type SandboxFileSystem, type SandboxInfo, type SandboxStatus, type SandboxTerminal, type TerminalComputeSandbox, type TerminalComputeSpecification, type TerminalCreateOptions, type TerminalProviderFactory, type TerminalSession, TimeoutError, autoSelectProvider, createComputeRegistry, ComputeSDK as default, detectAvailableProviders, executeSandbox, getDefaultRuntime, normalizeContainerConfig, normalizeSandboxConfig, retry, runCode, runCommand, validateProviderApiKey };