Sandbox SDK

A secure, isolated execution environment for running code with full VM capabilities, git integration, and agent-optimized APIs.

Import

import { $ } from 'sdk.do'

Operations

create

Create a new sandbox environment.

const result = await $.Sandbox.create({
  // parameters
})

delete

Permanently remove the sandbox.

const result = await $.Sandbox.delete({
  // parameters
})

execute

Run code within the sandbox.

const result = await $.Sandbox.execute({
  // parameters
})

terminate

Force stop any running sandbox execution.

const result = await $.Sandbox.terminate({
  // parameters
})

clone

Clone a git repository into the sandbox.

const result = await $.Sandbox.clone({
  // parameters
})

checkout

Switch to different branch or commit.

const result = await $.Sandbox.checkout({
  // parameters
})

pull

Pull latest changes from remote repository.

const result = await $.Sandbox.pull({
  // parameters
})

commit

Commit changes in sandbox to git.

const result = await $.Sandbox.commit({
  // parameters
})

push

Push committed changes to remote repository.

const result = await $.Sandbox.push({
  // parameters
})

install

Install dependencies (npm, pip, cargo, etc.).

const result = await $.Sandbox.install({
  // parameters
})

run

Execute shell command in sandbox.

const result = await $.Sandbox.run({
  // parameters
})

read

Read file contents from sandbox filesystem.

const result = await $.Sandbox.read({
  // parameters
})

write

Write content to file in sandbox.

const result = await $.Sandbox.write({
  // parameters
})

logs

Retrieve execution logs from sandbox.

const result = await $.Sandbox.logs({
  // parameters
})

reset

Clear sandbox state and return to initial configuration.

const result = await $.Sandbox.reset({
  // parameters
})

Events

created

Triggered when a new sandbox is created.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.created(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.created({ /* data */ })

deleted

Triggered when sandbox is removed.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.deleted(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.deleted({ /* data */ })

executed

Triggered when code runs in sandbox.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.executed(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.executed({ /* data */ })

terminated

Triggered when sandbox execution is force stopped.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.terminated(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.terminated({ /* data */ })

Repository.cloned

Triggered when git repository is cloned into sandbox.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Repository.cloned(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Repository.cloned({ /* data */ })

Branch.checkedOut

Triggered when branch or commit is checked out.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Branch.checkedOut(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Branch.checkedOut({ /* data */ })

Changes.pulled

Triggered when changes are pulled from remote.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Changes.pulled(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Changes.pulled({ /* data */ })

Changes.committed

Triggered when changes are committed to git.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Changes.committed(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Changes.committed({ /* data */ })

Commits.pushed

Triggered when commits are pushed to remote.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Commits.pushed(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Commits.pushed({ /* data */ })

Packages.installed

Triggered when dependencies are installed.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Packages.installed(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Packages.installed({ /* data */ })

Command.executed

Triggered when shell command runs.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Command.executed(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Command.executed({ /* data */ })

File.read

Triggered when file is read from filesystem.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.File.read(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.File.read({ /* data */ })

File.written

Triggered when file is written to filesystem.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.File.written(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.File.written({ /* data */ })

reset

Triggered when sandbox state is cleared.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.reset(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.reset({ /* data */ })

Permission.violated

Triggered when code attempts unauthorized action.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Permission.violated(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Permission.violated({ /* data */ })

Limit.exceeded

Triggered when resource limit is reached.

import { on, send } from 'sdk.do'

// Subscribe to event
on.Sandbox.Limit.exceeded(async (data) => {
  console.log('Event received:', data)
})

// Emit event
await send.Sandbox.Limit.exceeded({ /* data */ })

Sandbox SDK

On this page