@computesdk/daytona 1.0.1 → 1.1.1

package/README.md

@@ -1,85 +1,251 @@
 # @computesdk/daytona
 
-Daytona provider for ComputeSDK - Execute code in Daytona workspaces.
+Daytona provider for ComputeSDK - Execute code in Daytona development workspaces.
 
 ## Installation
 
 ```bash
-pnpm install @computesdk/daytona
+npm install @computesdk/daytona
 ```
 
 ## Usage
 
+### With ComputeSDK
+
 ```typescript
+import { compute } from 'computesdk';
 import { daytona } from '@computesdk/daytona';
 
-// Create a Daytona sandbox
-const sandbox = daytona({
-  runtime: 'python',
-  timeout: 30000
+// Set as default provider
+compute.setConfig({ 
+  provider: daytona({ apiKey: process.env.DAYTONA_API_KEY }) 
 });
 
+// Create sandbox
+const sandbox = await compute.sandbox.create({});
+
 // Execute code
-const result = await sandbox.execute('print("Hello from Daytona!")');
+const result = await sandbox.runCode('print("Hello from Daytona!")');
 console.log(result.stdout); // "Hello from Daytona!"
 
-// Run commands
-const cmdResult = await sandbox.runCommand('ls', ['-la']);
-console.log(cmdResult.stdout);
+// Clean up
+await compute.sandbox.destroy(sandbox.sandboxId);
+```
 
-// File operations
-await sandbox.filesystem.writeFile('/tmp/test.py', 'print("Hello World")');
-const content = await sandbox.filesystem.readFile('/tmp/test.py');
-console.log(content); // 'print("Hello World")'
+### Direct Usage
 
-// Clean up
-await sandbox.kill();
+```typescript
+import { daytona } from '@computesdk/daytona';
+
+// Create provider
+const provider = daytona({ 
+  apiKey: 'your-api-key',
+  runtime: 'python' 
+});
+
+// Use with compute singleton
+const sandbox = await compute.sandbox.create({ provider });
 ```
 
 ## Configuration
 
-Set your Daytona API key as an environment variable:
+### Environment Variables
 
 ```bash
 export DAYTONA_API_KEY=your_api_key_here
 ```
 
+### Configuration Options
+
+```typescript
+interface DaytonaConfig {
+  /** Daytona API key - if not provided, will use DAYTONA_API_KEY env var */
+  apiKey?: string;
+  /** Default runtime environment */
+  runtime?: 'python' | 'node';
+  /** Execution timeout in milliseconds */
+  timeout?: number;
+}
+```
+
 ## Features
 
-- ✅ Code execution in Python, Node.js, and other runtimes
-- ✅ Command execution
-- ✅ File system operations (read, write, mkdir, etc.)
-- ❌ Interactive terminal sessions (not supported)
+- ✅ **Code Execution** - Python and Node.js runtime support
+- ✅ **Command Execution** - Run shell commands in workspace
+- ✅ **Filesystem Operations** - Full file system access
+- ✅ **Auto Runtime Detection** - Automatically detects Python vs Node.js
+- ❌ **Interactive Terminals** - Not supported by Daytona SDK
 
 ## API Reference
 
-### `daytona(config?)`
+### Code Execution
+
+```typescript
+// Execute Python code
+const result = await sandbox.runCode(`
+import json
+data = {"message": "Hello from Python"}
+print(json.dumps(data))
+`, 'python');
+
+// Execute Node.js code  
+const result = await sandbox.runCode(`
+const data = { message: "Hello from Node.js" };
+console.log(JSON.stringify(data));
+`, 'node');
+
+// Auto-detection (based on code patterns)
+const result = await sandbox.runCode('print("Auto-detected as Python")');
+```
+
+### Command Execution
+
+```typescript
+// List files
+const result = await sandbox.runCommand('ls', ['-la']);
+
+// Install packages
+const result = await sandbox.runCommand('pip', ['install', 'requests']);
+
+// Run scripts
+const result = await sandbox.runCommand('python', ['script.py']);
+```
+
+### Filesystem Operations
+
+```typescript
+// Write file
+await sandbox.filesystem.writeFile('/workspace/hello.py', 'print("Hello World")');
+
+// Read file
+const content = await sandbox.filesystem.readFile('/workspace/hello.py');
+
+// Create directory
+await sandbox.filesystem.mkdir('/workspace/data');
 
-Creates a new Daytona sandbox instance.
+// List directory contents
+const files = await sandbox.filesystem.readdir('/workspace');
 
-**Parameters:**
-- `config` (optional): Configuration object
-  - `runtime`: Runtime environment ('python', 'node', etc.)
-  - `timeout`: Execution timeout in milliseconds
+// Check if file exists
+const exists = await sandbox.filesystem.exists('/workspace/hello.py');
 
-**Returns:** `DaytonaProvider` instance
+// Remove file or directory
+await sandbox.filesystem.remove('/workspace/hello.py');
+```
+
+### Sandbox Management
+
+```typescript
+// Get sandbox info
+const info = await sandbox.getInfo();
+console.log(info.id, info.provider, info.status);
+
+// List all sandboxes
+const sandboxes = await compute.sandbox.list(provider);
+
+// Get existing sandbox
+const existing = await compute.sandbox.getById(provider, 'sandbox-id');
+
+// Destroy sandbox
+await compute.sandbox.destroy(provider, 'sandbox-id');
+```
+
+## Runtime Detection
+
+The provider automatically detects the runtime based on code patterns:
+
+**Python indicators:**
+- `print(` statements
+- `import` statements  
+- `def` function definitions
+- Python-specific syntax (`f"`, `__`, etc.)
+
+**Default:** Node.js for all other cases
+
+## Error Handling
+
+```typescript
+try {
+  const result = await sandbox.runCode('invalid code');
+} catch (error) {
+  if (error.message.includes('Syntax error')) {
+    console.error('Code has syntax errors');
+  } else if (error.message.includes('authentication failed')) {
+    console.error('Check your DAYTONA_API_KEY');
+  } else if (error.message.includes('quota exceeded')) {
+    console.error('Daytona usage limits reached');
+  }
+}
+```
+
+## Web Framework Integration
+
+Use with web frameworks via the request handler:
+
+```typescript
+import { handleComputeRequest } from 'computesdk';
+import { daytona } from '@computesdk/daytona';
 
-### Methods
+export async function POST(request: Request) {
+  return handleComputeRequest({
+    request,
+    provider: daytona({ apiKey: process.env.DAYTONA_API_KEY })
+  });
+}
+```
+
+## Examples
 
-- `execute(code, runtime?)`: Execute code in the sandbox
-- `runCode(code, runtime?)`: Alias for execute
-- `runCommand(command, args?)`: Execute shell commands
-- `kill()`: Terminate the sandbox
-- `getInfo()`: Get sandbox information
+### Data Processing
 
-### File System
+```typescript
+const result = await sandbox.runCode(`
+import json
+
+# Process data
+data = [1, 2, 3, 4, 5]
+result = {
+    "sum": sum(data),
+    "average": sum(data) / len(data),
+    "max": max(data)
+}
+
+print(json.dumps(result))
+`);
+
+const output = JSON.parse(result.stdout);
+console.log(output); // { sum: 15, average: 3, max: 5 }
+```
 
-- `filesystem.readFile(path)`: Read file contents
-- `filesystem.writeFile(path, content)`: Write file contents
-- `filesystem.mkdir(path)`: Create directory
-- `filesystem.readdir(path)`: List directory contents
-- `filesystem.exists(path)`: Check if file/directory exists
-- `filesystem.remove(path)`: Remove file/directory
+### File Processing
+
+```typescript
+// Create data file
+await sandbox.filesystem.writeFile('/workspace/data.json', 
+  JSON.stringify({ users: ['Alice', 'Bob', 'Charlie'] })
+);
+
+// Process file
+const result = await sandbox.runCode(`
+import json
+
+with open('/workspace/data.json', 'r') as f:
+    data = json.load(f)
+
+# Process users
+user_count = len(data['users'])
+print(f"Found {user_count} users")
+
+# Save result
+result = {"user_count": user_count, "processed": True}
+with open('/workspace/result.json', 'w') as f:
+    json.dump(result, f)
+`);
+
+// Read result
+const resultData = await sandbox.filesystem.readFile('/workspace/result.json');
+console.log(JSON.parse(resultData));
+```
 
 ## License
 

package/dist/index.d.mts

@@ -1,4 +1,5 @@
-import { Runtime, Provider, ProviderSandboxManager } from 'computesdk';
+import * as computesdk from 'computesdk';
+import { Runtime } from 'computesdk';
 
 /**
  * Daytona-specific configuration options
@@ -12,16 +13,8 @@ interface DaytonaConfig {
     timeout?: number;
 }
 /**
- * Daytona Provider implementation
+ * Create a Daytona provider instance using the factory pattern
  */
-declare class DaytonaProvider implements Provider {
-    readonly name = "daytona";
-    readonly sandbox: ProviderSandboxManager;
-    constructor(config?: DaytonaConfig);
-}
-/**
- * Create a Daytona provider instance
- */
-declare function daytona(config?: DaytonaConfig): DaytonaProvider;
+declare const daytona: (config: DaytonaConfig) => computesdk.Provider;
 
-export { type DaytonaConfig, DaytonaProvider, daytona };
+export { type DaytonaConfig, daytona };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { Runtime, Provider, ProviderSandboxManager } from 'computesdk';
+import * as computesdk from 'computesdk';
+import { Runtime } from 'computesdk';
 
 /**
  * Daytona-specific configuration options
@@ -12,16 +13,8 @@ interface DaytonaConfig {
     timeout?: number;
 }
 /**
- * Daytona Provider implementation
+ * Create a Daytona provider instance using the factory pattern
  */
-declare class DaytonaProvider implements Provider {
-    readonly name = "daytona";
-    readonly sandbox: ProviderSandboxManager;
-    constructor(config?: DaytonaConfig);
-}
-/**
- * Create a Daytona provider instance
- */
-declare function daytona(config?: DaytonaConfig): DaytonaProvider;
+declare const daytona: (config: DaytonaConfig) => computesdk.Provider;
 
-export { type DaytonaConfig, DaytonaProvider, daytona };
+export { type DaytonaConfig, daytona };