@sandboxxjs/core 0.1.0

package/README.md

@@ -0,0 +1,60 @@
+# @@sandboxxjs/sandbox/core
+
+Core implementation for SandboX - secure code execution engine.
+
+## Features
+
+- Multiple isolators (Local, Cloudflare, E2B, Firecracker)
+- Multiple runtimes (Node.js, Python, Bash, Docker)
+- File system operations
+- Resource limits
+- Event-driven architecture
+
+## Installation
+
+```bash
+npm install @@sandboxxjs/sandbox/core
+```
+
+## Usage
+
+```typescript
+import { Sandbox, LocalIsolator } from "@@sandboxxjs/sandbox/core";
+
+const isolator = new LocalIsolator("node");
+const sandbox = new Sandbox({
+  runtime: "node",
+  isolator: "local",
+});
+
+const result = await sandbox.execute({
+  code: 'console.log("Hello")',
+});
+
+console.log(result.stdout); // "Hello"
+```
+
+## API
+
+### Sandbox
+
+```typescript
+class Sandbox {
+  execute(options: ExecuteOptions): Promise<ExecuteResult>;
+  writeFile(path: string, data: string): Promise<void>;
+  readFile(path: string): Promise<string>;
+  destroy(): Promise<void>;
+  on(event: string, handler: Function): void;
+  fs: FileSystem;
+}
+```
+
+### Isolators
+
+- `LocalIsolator` - Process isolation via execa
+- `CloudflareContainerIsolator` - Docker via Bun binary
+- `E2BIsolator` - E2B microVM (not yet implemented)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,135 @@
+/**
+* Core type definitions for SandboX
+*/
+type Runtime = "bash" | "node" | "python" | "docker";
+type IsolatorType = "local" | "cloudflare" | "e2b" | "firecracker" | "docker";
+interface SandboxConfig {
+	runtime: Runtime;
+	isolator: IsolatorType;
+	limits?: ResourceLimits;
+	isolation?: IsolationConfig;
+}
+interface ResourceLimits {
+	timeout?: number;
+	memory?: number;
+	cpu?: number;
+}
+interface IsolationConfig {
+	networkAccess?: boolean;
+	fileSystemAccess?: boolean;
+	envVars?: Record<string, string>;
+}
+interface ExecuteOptions {
+	code: string;
+	env?: Record<string, string>;
+	timeout?: number;
+}
+interface ExecuteResult {
+	success: boolean;
+	data?: unknown;
+	stdout?: string;
+	stderr?: string;
+	error?: string;
+	exitCode?: number;
+	metadata: {
+		executionTime: number
+		timestamp: string
+	};
+}
+interface FileSystem {
+	write(path: string, data: string): Promise<void>;
+	read(path: string): Promise<string>;
+	list(path: string): Promise<string[]>;
+	delete(path: string): Promise<void>;
+	exists(path: string): Promise<boolean>;
+}
+type EventHandler = (...args: unknown[]) => void;
+declare class Sandbox {
+	private isolator;
+	private runtime;
+	private eventHandlers;
+	fs: FileSystem;
+	constructor(config: SandboxConfig);
+	private createIsolator;
+	private createRuntime;
+	execute(options: ExecuteOptions): Promise<ExecuteResult>;
+	writeFile(filePath: string, data: string): Promise<void>;
+	readFile(filePath: string): Promise<string>;
+	destroy(): Promise<void>;
+	on(event: string, handler: EventHandler): void;
+	private emit;
+}
+declare abstract class Isolator {
+	abstract execute(options: ExecuteOptions): Promise<ExecuteResult>;
+	abstract getFileSystem(): FileSystem;
+	abstract destroy(): Promise<void>;
+}
+declare class LocalIsolator extends Isolator {
+	private workDir;
+	private runtime;
+	constructor(runtime?: string);
+	execute(options: ExecuteOptions): Promise<ExecuteResult>;
+	/**
+	* Build command array based on runtime
+	*/
+	private buildCommand;
+	getFileSystem(): FileSystem;
+	destroy(): Promise<void>;
+}
+declare class CloudflareContainerIsolator extends Isolator {
+	private serverProcess?;
+	private serverUrl?;
+	private isReady;
+	private runtime;
+	constructor(runtime?: string);
+	/**
+	* Find an available port
+	*/
+	private findFreePort;
+	/**
+	* Get binary path from installed package
+	*/
+	private getBinaryPath;
+	/**
+	* Wait for server to be ready
+	*/
+	private waitForReady;
+	/**
+	* Ensure server is running
+	*/
+	private ensureServerRunning;
+	execute(options: ExecuteOptions): Promise<ExecuteResult>;
+	getFileSystem(): FileSystem;
+	destroy(): Promise<void>;
+}
+declare abstract class Runtime2 {
+	abstract execute(options: ExecuteOptions): Promise<ExecuteResult>;
+	abstract prepare(): Promise<void>;
+	abstract cleanup(): Promise<void>;
+}
+declare class GenericRuntime extends Runtime2 {
+	private isolator;
+	constructor(isolator: Isolator);
+	execute(options: ExecuteOptions): Promise<ExecuteResult>;
+	prepare(): Promise<void>;
+	cleanup(): Promise<void>;
+}
+/**
+* Error types for SandboX
+*/
+declare class SandboxError extends Error {
+	constructor(message: string);
+}
+declare class ExecutionError extends SandboxError {
+	constructor(message: string);
+}
+declare class TimeoutError extends SandboxError {
+	constructor(message: string);
+}
+declare class IsolationError extends SandboxError {
+	constructor(message: string);
+}
+declare class FileSystemError extends SandboxError {
+	constructor(message: string);
+}
+export { TimeoutError, SandboxError, SandboxConfig, Sandbox, Runtime2 as Runtime, ResourceLimits, LocalIsolator, IsolatorType, Isolator, IsolationError, IsolationConfig, GenericRuntime, FileSystemError, FileSystem, ExecutionError, ExecuteResult, ExecuteOptions, EventHandler, CloudflareContainerIsolator };