@computesdk/codesandbox

CodeSandbox provider for ComputeSDK - Execute code in secure, isolated CodeSandbox environments with full filesystem and development environment support.

Installation

``bash
npm install @computesdk/codesandbox
`

Setup

1. Get your CodeSandbox API key from codesandbox.io/t/api
2. Set the environment variable:

`bash
export CSB_API_KEY=your_api_key_here
`

Quick Start

$3

Use the gateway for zero-config auto-detection:

`typescript
import { compute } from 'computesdk';

// Auto-detects CodeSandbox from CSB_API_KEY environment variable
const sandbox = await compute.sandbox.create();

// Execute JavaScript/Node.js code
const result = await sandbox.runCode(
const message = "Hello from CodeSandbox!";
console.log(message);

const data = { users: 3, tasks: 15 };
console.log(JSON.stringify(data, null, 2));
);

console.log(result.stdout);
// Output:
// Hello from CodeSandbox!
// {
// "users": 3,
// "tasks": 15
// }

// Execute Python code
const pythonResult = await sandbox.runCode(
import json
data = {"framework": "CodeSandbox", "language": "Python"}
print(json.dumps(data, indent=2))
print(f"Running in: {data['framework']}")
, 'python');

console.log(pythonResult.stdout);
// Output:
// {
// "framework": "CodeSandbox",
// "language": "Python"
// }
// Running in: CodeSandbox

await sandbox.destroy();
`

$3

For direct SDK usage without the gateway:

`typescript
import { codesandbox } from '@computesdk/codesandbox';

const compute = codesandbox({
apiKey: process.env.CSB_API_KEY,
templateId: 'universal', // Optional: specify template
timeout: 600000 // 10 minutes
});

const sandbox = await compute.sandbox.create();

const result = await sandbox.runCode('console.log("Hello from CodeSandbox!");');
console.log(result.stdout);

await sandbox.destroy();
`

Configuration

$3

`bash
export CSB_API_KEY=your_api_key_here
`

$3

`typescript
interface CodesandboxConfig {
/* CodeSandbox API key - if not provided, will use CSB_API_KEY env var /
apiKey?: string;
/* Template to use for new sandboxes (defaults to universal template) /
templateId?: string;
/* Default runtime environment /
runtime?: 'python' | 'node';
/* Execution timeout in milliseconds /
timeout?: number;
}
`

Features

- ✅ Code Execution - Python and Node.js runtime support
- ✅ Command Execution - Run shell commands in sandbox
- ✅ Filesystem Operations - Full file system access via CodeSandbox API
- ✅ Template Support - Create sandboxes from custom templates
- ✅ Auto Runtime Detection - Automatically detects Python vs Node.js
- ✅ Development Environment - Full development setup with package managers
- ✅ Persistence - Files persist across hibernation/resume cycles
- ✅ Snapshot/Resume - Fast sandbox restoration from snapshots

API Reference

$3

`typescript
// Execute Node.js code
const result = await sandbox.runCode(
const fs = require('fs');
const data = { timestamp: Date.now() };
console.log('Processing data:', JSON.stringify(data));
);

// Execute Python code
const result = await sandbox.runCode(
import datetime
import json

data = {'timestamp': datetime.datetime.now().isoformat()}
print('Processing data:', json.dumps(data))
, 'python');

// Auto-detection (based on code patterns)
const result = await sandbox.runCode('print("Auto-detected as Python")');
`

$3

`typescript
// List files
const result = await sandbox.runCommand('ls', ['-la']);

// Install Node.js packages
const result = await sandbox.runCommand('npm', ['install', 'lodash']);

// Install Python packages
const result = await sandbox.runCommand('pip', ['install', 'requests']);

// Run development server
const result = await sandbox.runCommand('npm', ['run', 'dev']);
`

$3

`typescript
// Write file
await sandbox.filesystem.writeFile('/project/workspace/app.js',
const express = require('express');
const app = express();

app.get('/', (req, res) => {
res.json({ message: 'Hello from CodeSandbox!' });
});

app.listen(3000, () => {
console.log('Server running on port 3000');
});
);

// Read file
const content = await sandbox.filesystem.readFile('/project/workspace/package.json');

// Create directory
await sandbox.filesystem.mkdir('/project/workspace/src');

// List directory contents
const files = await sandbox.filesystem.readdir('/project/workspace');

// Check if file exists
const exists = await sandbox.filesystem.exists('/project/workspace/app.js');

// Remove file or directory
await sandbox.filesystem.remove('/project/workspace/temp.txt');
`

$3

`typescript
// Get sandbox info
const info = await sandbox.getInfo();
console.log(info.id, info.provider, info.status);

// Resume existing sandbox
const existing = await compute.sandbox.getById(provider, 'sandbox-id');

// Hibernate sandbox (saves state)
await compute.sandbox.destroy(provider, 'sandbox-id'); // Actually hibernates

// Note: CodeSandbox doesn't support listing all sandboxes
// Each sandbox is managed individually
`

Best Practices

1. Resource Management: Use hibernation instead of destroying sandboxes to preserve state
2. Error Handling: Use try-catch blocks for robust error handling
3. Timeouts: Set appropriate timeouts for long-running tasks
4. File Organization: Organize files in /project/workspace/` directory
5. Template Usage: Use appropriate templates for your project type
6. API Key Security: Never commit API keys to version control
7. Snapshot Management: Leverage CodeSandbox's snapshot/resume capabilities

Support

- CodeSandbox Documentation
- ComputeSDK Issues
- CodeSandbox Support

License

MIT