<p align="center" style="font-size: 48px; font-weight: bold;">Work in Progress</p>
# Daytona Client for Rust
[](https://crates.io/crates/daytona-client)
[](https://docs.rs/daytona-client)
[](https://github.com/krzysztofwos/daytona-client#license)
[](https://github.com/krzysztofwos/daytona-client/actions)
A Rust client library for the [Daytona API](https://www.daytona.io), providing secure sandbox environments for code execution and development.
## Status
**Version 0.3.0** — API parity with official SDKs for all implemented features.
### Current Features
- ✅ **Sandboxes**: Create, list, get, delete, start, stop, archive operations
- ✅ **Workspaces**: Full workspace lifecycle management
- ✅ **Process Execution**: Execute commands with sessions and timeout support
- ✅ **Session Management**: Create and manage persistent command sessions
- ✅ **File Operations**: Upload, download, list, move, copy, delete files and directories
- ✅ **Git Operations**: Clone, commit, push, pull, branch management, status, history
- ✅ **Type Safety**: Strongly typed models with comprehensive error handling
- ✅ **API Parity**: Complete parity with official SDKs for implemented endpoints
### Known API Issues
These are server-side API bugs, not client library issues:
- ⚠️ **Process Execution**: `cwd` parameter exists but doesn't work correctly
- ⚠️ **Sandbox Creation**: API incorrectly rejects resource specifications (cpu, memory, disk) claiming a snapshot is used when it isn't
All other features are fully functional and tested.
## Installation
Add this to your `Cargo.toml`:
```toml
[dependencies]
daytona-client = "0.3"
```
## Quick Start
```rust
use daytona_client::{DaytonaClient, CreateSandboxParams};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Create client from environment variables
let client = DaytonaClient::from_env()?;
// Create a sandbox
let sandbox = client.sandboxes()
.create(CreateSandboxParams {
class: Some("small".to_string()),
..Default::default()
})
.await?;
// Execute a command
let result = client.process()
.execute_command(&sandbox.id, "echo 'Hello from Daytona!'")
.await?;
println!("Output: {}", result.result);
// Clean up
client.sandboxes().delete(&sandbox.id).await?;
Ok(())
}
```
## Environment Variables
The client can be configured using environment variables:
- `DAYTONA_API_KEY` — Daytona API key (required)
- `DAYTONA_BASE_URL` — API base URL (default: `https://app.daytona.io/api`)
- `DAYTONA_ORGANIZATION_ID` — Organization ID for multi-org accounts (optional)
## Implementation Status
### API Endpoints
- ✅ **Sandbox Management**: Create, list, get, delete, start, stop, archive
- ✅ **Workspace Management**: Create, list, get, delete, start, stop, archive
- ✅ **Process Execution**: Execute commands, session management
- ✅ **File Operations**: Full file and directory management via upload/download/list/move/copy/delete
- ✅ **Git Operations**: Clone, commit, push, pull, branch, status, history, stage
- ❌ **Organization Management**: Not yet implemented
- ❌ **Port Forwarding**: Not yet implemented
- ❌ **WebSocket Connections**: Not yet implemented
- ❌ **LSP Integration**: Not yet implemented
### Testing Status
**47 integration tests** covering all implemented features:
- ✅ **Sandbox Integration Tests**: Full lifecycle and operation testing
- ✅ **Workspace Integration Tests**: Complete workspace management testing
- ✅ **Process Integration Tests**: Command execution and session management
- ✅ **File Integration Tests**: Upload, download, and file management operations
- ✅ **Git Integration Tests**: Repository operations and branch management
## Examples
### Basic Sandbox Operations
```rust
use daytona_client::{DaytonaClient, CreateSandboxParams};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = DaytonaClient::from_env()?;
// Create a sandbox
let sandbox = client.sandboxes()
.create(CreateSandboxParams {
class: Some("small".to_string()),
..Default::default()
})
.await?;
println!("Created sandbox: {}", sandbox.id);
// Execute a command
let result = client.process()
.execute_command(&sandbox.id, "echo 'Hello from Daytona!'")
.await?;
println!("Output: {}", result.result);
// Clean up
client.sandboxes().delete(&sandbox.id).await?;
Ok(())
}
```
### File Operations
```rust
// Upload a file
client.files()
.upload(&sandbox.id, "/app/main.py", b"print('Hello World!')")
.await?;
// Download a file
let content = client.files()
.download(&sandbox.id, "/app/main.py")
.await?;
// List directory contents
let entries = client.files()
.list(&sandbox.id, "/app")
.await?;
```
### Git Operations
```rust
use daytona_client::GitCloneRequest;
// Clone a repository
let clone_request = GitCloneRequest {
url: "https://github.com/user/repo.git".to_string(),
path: "/workspace".to_string(),
branch: Some("main".to_string()),
depth: Some(1),
auth_token: None,
ssh_key: None,
};
client.git()
.clone(&sandbox.id, clone_request)
.await?;
// Check status
let status = client.git()
.status(&sandbox.id, "/workspace")
.await?;
println!("Current branch: {}", status.current_branch);
```
### Session Management
```rust
use daytona_client::SessionExecuteRequest;
// Create a persistent session
let session_id = "my-session";
client.process()
.create_session(&sandbox.id, session_id)
.await?;
// Execute commands in the session
let response = client.process()
.execute_session_command(&sandbox.id, session_id, SessionExecuteRequest {
command: "python -c 'x = 42; print(f\"x = {x}\")'".to_string(),
run_async: Some(false),
})
.await?;
println!("Session output: {:?}", response.output);
```
### Workspace Management
```rust
use daytona_client::{CreateWorkspaceParams, WorkspaceState};
// Create a workspace
let workspace = client.workspaces()
.create(CreateWorkspaceParams {
name: "my-project".to_string(),
description: Some("Development environment".to_string()),
class: Some("small".to_string()),
..Default::default()
})
.await?;
// Wait for it to start
let workspace = client.workspaces()
.wait_for_state(&workspace.id, WorkspaceState::Started, 120)
.await?;
println!("Workspace {} is ready!", workspace.id);
```
## Error Handling
The client provides comprehensive error types:
```rust
use daytona_client::{DaytonaError, Result};
match client.sandboxes().create(params).await {
Ok(sandbox) => println!("Created: {}", sandbox.id),
Err(DaytonaError::QuotaExceeded(msg)) => {
eprintln!("Quota exceeded: {}", msg);
}
Err(DaytonaError::AuthenticationFailed(msg)) => {
eprintln!("Auth failed: {}", msg);
}
Err(e) => eprintln!("Error: {}", e),
}
```
## Testing
### Prerequisites
Set the Daytona API key:
```bash
export DAYTONA_API_KEY="api-key"
```
### Running Tests
Tests that create sandboxes are automatically run sequentially using the `serial_test` crate to avoid exceeding Daytona's 30GB quota limit:
```bash
# Run all tests (resource-intensive tests run sequentially)
cargo test
# Run specific test suites
cargo test --test sandbox_integration
cargo test --test workspace_integration
cargo test --test process_integration
cargo test --test files_integration
cargo test --test git_integration
```
### Cleanup Utilities
If tests fail or are interrupted, sandboxes may not be cleaned up. Use the provided utilities:
```bash
# Check current resource usage
cargo run --bin verify-cleanup
# Clean up test sandboxes only (safer)
cargo run --bin cleanup-test-sandboxes
# Force cleanup all resources (interactive)
cargo run --bin force-cleanup
```
## Contributing
Contributions are welcome. Please feel free to submit a Pull Request.
## License
This project is licensed under either of:
- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
- MIT license ([LICENSE-MIT](LICENSE-MIT))
at the option of the user.
## Acknowledgments
This client is not officially affiliated with Daytona. For official SDKs, visit [Daytona's documentation](https://www.daytona.io/docs).