Microsandbox

https://github.com/superradcompany/microsandbox
Admin
Microsandbox is a lightweight VM platform that spins up microVMs in milliseconds with hardware...
Tokens:407,083
Snippets:5,453
Trust Score:9
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Example Dependencies

Source: https://github.com/superradcompany/microsandbox/blob/main/examples/typescript/README.md

Navigate to the specific example directory and install the required dependencies.

```sh
cd examples/typescript/<example>
npm install
```

--------------------------------

### Run Example

Source: https://github.com/superradcompany/microsandbox/blob/main/examples/typescript/README.md

Execute the start script for the current example project.

```sh
npm start
```

--------------------------------

### Install and start a service

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/guest/systemd-services.mdx

Install a package and start it using systemctl enable --now.

```bash
root@msb:/# apt update && apt install -y nginx
root@msb:/# systemctl enable --now nginx
root@msb:/# curl -s localhost | head -1
<!DOCTYPE html>
```

--------------------------------

### Sandbox.start method signature and example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/sandbox.mdx

The method signature for starting a previously stopped sandbox and an example of its usage.

```python
@staticmethod
async def start(name: str, *, detached: bool = False) -> Sandbox
```

```python
sb = await Sandbox.start("api")
```

--------------------------------

### Run root-oci Example

Source: https://github.com/superradcompany/microsandbox/blob/main/examples/typescript/README.md

Example workflow for installing and running the root-oci sandbox project.

```sh
cd examples/typescript/root-oci
npm install
npm start
```

--------------------------------

### Quick Start Sandbox Creation

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/go/README.md

A complete example demonstrating how to initialize the environment, create a sandbox with specific resources, execute a command, and clean up.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "time"

    microsandbox "github.com/superradcompany/microsandbox/sdk/go"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
    defer cancel()

    if err := microsandbox.EnsureInstalled(ctx); err != nil {
        log.Fatal(err)
    }

    name := "go-readme"
    sb, err := microsandbox.CreateSandbox(ctx, name,
        microsandbox.WithImage("alpine:3.19"),
        microsandbox.WithMemory(512),
        microsandbox.WithCPUs(1),
        microsandbox.WithReplace(),
    )
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        stopCtx, stopCancel := context.WithTimeout(context.Background(), 30*time.Second)
        defer stopCancel()
        _ = sb.Stop(stopCtx)
        _ = sb.Close()
        _ = microsandbox.RemoveSandbox(context.Background(), name)
    }()

    out, err := sb.Shell(ctx, "echo 'Hello from microsandbox!'")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(out.Stdout())
}
```

--------------------------------

### Create the startup script start-desktop.sh

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/development/vnc-desktop.mdx

This script installs necessary desktop packages, configures LXQt and Openbox, starts the TigerVNC server, and launches the noVNC websockify proxy.

```sh
#!/bin/sh
set -eu

apt-get update
DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
  breeze-icon-theme ca-certificates dbus-x11 lxqt-core novnc openbox \
  qterminal tigervnc-standalone-server websockify
rm -rf /var/lib/apt/lists/*

mkdir -p /root/.config/lxqt /root/.config/openbox /tmp/runtime-root
chmod 700 /tmp/runtime-root
sed -e "s/,quicklaunch//" -e "/^\[quicklaunch\]/,/^$/d" \
  /usr/share/lxqt/panel.conf > /root/.config/lxqt/panel.conf
sed "s#<name>Clearlooks</name>#<name>Breeze-ob</name>#" \
  /etc/xdg/openbox/rc.xml > /root/.config/openbox/rc.xml

Xtigervnc :1 -SecurityTypes None -geometry 1440x900 -depth 24 >/tmp/xvnc.log 2>&1 &
vnc_pid=$!
sleep 2
if ! kill -0 "$vnc_pid"; then
  cat /tmp/xvnc.log >&2
  exit 1
fi
cat /tmp/xvnc.log

DISPLAY=:1 XDG_RUNTIME_DIR=/tmp/runtime-root \
  dbus-launch --exit-with-session sh -c "
    startlxqt &
    session_pid=\$!
    sleep 4
    kill -0 \"\$session_pid\"
    qterminal &
    wait \"\$session_pid\"
  " >/tmp/lxqt.log 2>&1 &
desktop_pid=$!
sleep 5
if ! kill -0 "$desktop_pid"; then
  cat /tmp/lxqt.log >&2
  exit 1
fi

exec websockify --web=/usr/share/novnc 0.0.0.0:6080 localhost:5901
```

--------------------------------

### Clone and setup repository

Source: https://github.com/superradcompany/microsandbox/blob/main/DEVELOPMENT.md

Clone the microsandbox repository and execute the initial setup command to install dependencies and build binaries.

```bash
git clone https://github.com/microsandbox/microsandbox.git
cd microsandbox
just setup
```

--------------------------------

### Install and verify runtime in Rust

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Uses the setup module to verify and install the runtime, returning a result that can be handled with the question mark operator.

```rust
use microsandbox::setup;

if !setup::is_installed() {
    setup::install().await?;
}
```

--------------------------------

### Install microsandbox SDK for Go

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/getting-started/quickstart.mdx

Install the microsandbox SDK via go get.

```bash
go get github.com/superradcompany/microsandbox/sdk/go
```

--------------------------------

### LogStream usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/sandbox.mdx

Demonstrates how to start a streaming log subscription and process entries in a loop.

```go
stream, err := sb.LogStream(ctx, m.LogStreamOptions{Follow: true})
if err != nil {
    return err
}
defer stream.Close()
for {
    entry, err := stream.Recv(ctx)
    if err != nil || entry == nil {
        break
    }
    fmt.Print(entry.Text())
}
```

--------------------------------

### msb start command examples

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/cli/sandbox-commands.mdx

Resume stopped sandboxes by name or by using labels to select multiple sandboxes.

```bash
msb start devbox
msb start --label app=engine          # Start every sandbox labeled app=engine
```

--------------------------------

### StartSandbox Usage Example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/sandbox.mdx

Starts a previously stopped sandbox named 'api'.

```go
sb, err := m.StartSandbox(ctx, "api")
```

--------------------------------

### Run SDK Examples

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/go/README.md

Commands to execute the self-contained example programs located in the examples directory.

```bash
go run ./examples/basic
go run ./examples/network
go run ./examples/snapshot-fork
```

--------------------------------

### Install the package

Source: https://github.com/superradcompany/microsandbox/blob/main/packages/agent-client/typescript/README.md

Install the client via npm.

```bash
npm install @microsandbox/agent-client
```

--------------------------------

### Run basic Go example

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/go/examples/README.md

Execute the basic example project from the sdk/go directory.

```sh
go run ./examples/basic
```

--------------------------------

### MetricsStream usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/sandbox.mdx

Example showing how to start a metrics stream, receive snapshots in a loop, and close the handle.

```go
stream, err := sb.MetricsStream(ctx, 500*time.Millisecond)
if err != nil {
    return err
}
defer stream.Close()
for {
    metrics, err := stream.Recv(ctx)
    if err != nil || metrics == nil {
        break
    }
    fmt.Printf("CPU: %.1f%%\n", metrics.CPUPercent)
}
```

--------------------------------

### Customize TypeScript installation

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Use the setup builder to configure the base directory, version, verification, and force download settings in TypeScript.

```typescript
import { setup } from "microsandbox";

await setup()
  .baseDir("/opt/microsandbox")
  .version("0.6.8")
  .skipVerify(false)
  .force(true)
  .install();
```

--------------------------------

### Rust Setup Builder

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Configures and executes the microsandbox installation using the Rust builder pattern.

```APIDOC
## Rust Setup Builder

### Description
Configures the installation environment using the `Setup::builder()` pattern.

### Method
`Setup::builder().base_dir().version().skip_verify().force().build().install()`

### Parameters
- **base_dir** (string) - Optional - Sets the installation root directory.
- **version** (string) - Optional - Specifies the runtime version to install.
- **skip_verify** (boolean) - Optional - Toggles post-install verification.
- **force** (boolean) - Optional - Forces a download even if files exist.
```

--------------------------------

### Start Gemini CLI on Windows

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/gemini-cli.mdx

Initializes a microsandbox with a writable host-directory mount and installs the Gemini CLI using PowerShell syntax.

```powershell
msb run -t --name gemini-demo --replace `
  --cpus 2 --memory 2G --root-disk 4G `
  --mount-dir ./my-project:/workspace:rw `
  --workdir /workspace `
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @google/gemini-cli@0.52.0 &&
    exec gemini
  '
```

--------------------------------

### Customize Rust installation

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Use the Setup builder to configure the base directory, version, verification, and force download settings in Rust.

```rust
use microsandbox::setup::Setup;

Setup::builder()
    .base_dir("/opt/microsandbox")
    .version("0.6.8")
    .skip_verify(false)
    .force(true)
    .build()
    .install()
    .await?;
```

--------------------------------

### CopyFromHost usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/filesystem.mdx

Example of copying a file from the host to the sandbox.

```go
err := fs.CopyFromHost(ctx, "./seed.db", "/app/data/seed.db")
```

--------------------------------

### CopyToHost usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/filesystem.mdx

Example of copying a file from the sandbox to the host.

```go
err := fs.CopyToHost(ctx, "/app/output/report.csv", "./report.csv")
```

--------------------------------

### sb.attach() example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/rust/execution.mdx

Example usage of attach to start an interactive bash session.

```rust
let exit_code = sb.attach("bash", ["-l"]).await?;
```

--------------------------------

### Initialization and volume example commands

Source: https://github.com/superradcompany/microsandbox/blob/main/examples/rust/README.md

Commands to run init handoff and volume management examples.

```sh
cargo run -p init-handoff
cargo run -p volume-named
cargo run -p volume-disk
```

--------------------------------

### Install Microsandbox SDK

Source: https://github.com/superradcompany/microsandbox/blob/main/README.md

Install the SDK for your preferred programming language.

```sh
npm i microsandbox                                       # 🟦 TypeScript
```

```sh
cargo add microsandbox                                   # 🦀 Rust
```

```sh
uv add microsandbox                                      # 🐍 Python
```

```sh
go get github.com/superradcompany/microsandbox/sdk/go    # 🐹 Go
```

--------------------------------

### Close usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/ssh.mdx

Example showing how to release the prepared server endpoint.

```go
defer srv.Close(ctx)
```

--------------------------------

### Booting a sandbox from a snapshot or image

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/snapshots.mdx

Examples showing how to boot a sandbox from a snapshot versus an image. Note that from_snapshot and image are mutually exclusive.

```python
# Boot from a snapshot
sb = await Sandbox.create("worker", from_snapshot="after-pip-install")

# Or from an image (existing flow, unchanged)
sb = await Sandbox.create("worker", image="python:3.12")
```

--------------------------------

### PrepareServer usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/ssh.mdx

Example of preparing an SSH server with a custom authorized keys path.

```go
srv, err := sb.SSH().PrepareServer(ctx,
    m.WithSSHAuthorizedKeysPath("/etc/msb/authorized_keys"),
)
if err != nil {
    return err
}
defer srv.Close(ctx)
```

--------------------------------

### Run the preparation script

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/file-processing/libreoffice-pdf.mdx

Install the scripts and run the preparation entrypoint.

```sh
msb run --name office-base --replace \
  --cpus 2 --memory 2G --root-disk 5G \
  --script-path prepare-office:./prepare-office.sh \
  --script-path convert-document:./convert-document.sh \
  --entrypoint prepare-office \
  debian:bookworm-slim
```

```powershell
msb run --name office-base --replace `
  --cpus 2 --memory 2G --root-disk 5G `
  --script-path prepare-office:./prepare-office.sh `
  --script-path convert-document:./convert-document.sh `
  --entrypoint prepare-office `
  debian:bookworm-slim
```

--------------------------------

### Start Claude Code (Windows)

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/claude-code.mdx

Starts a microVM with a writable host-directory mount and installs the pinned Claude Code package on Windows.

```powershell
msb run -t --name claude-code-demo --replace `
  --cpus 2 --memory 4G --root-disk 4G `
  --mount-dir ./my-project:/workspace:rw `
  --workdir /workspace `
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @anthropic-ai/claude-code@2.1.235 &&
    exec claude
  '
```

--------------------------------

### Minimal example in Go

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/getting-started/introduction.mdx

Create a sandbox using the Python image and execute a print command.

```go
sb, err := m.CreateSandbox(ctx, "hello", m.WithImage("python"))
if err != nil {
    return err
}
defer sb.Stop(ctx)

out, err := sb.Exec(ctx, "python", []string{"-c", "print('Hello from a microVM!')"})
if err != nil {
    return err
}
fmt.Println(out.Stdout())
```

--------------------------------

### Start Claude Code (macOS & Linux)

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/claude-code.mdx

Starts a microVM with a writable host-directory mount and installs the pinned Claude Code package.

```sh
msb run -t --name claude-code-demo --replace \
  --cpus 2 --memory 4G --root-disk 4G \
  --mount-dir ./my-project:/workspace:rw \
  --workdir /workspace \
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @anthropic-ai/claude-code@2.1.235 &&
    exec claude
  '
```

--------------------------------

### ExecStream Usage Example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/execution.mdx

Example of starting a streaming exec session with stdin pipe enabled. The returned handle must be closed.

```go
h, err := sb.ExecStream(ctx, "cat", nil, m.WithExecStdinPipe())
if err != nil {
    return err
}
defer h.Close()
```

--------------------------------

### Modify Sandbox Configuration Examples

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/sandbox.mdx

Examples demonstrating live resizing, dry-run previews, environment changes, disk resizing, and secret management.

```go
// Live resize: applies to the running VM when within the booted capacity
plan, err := sb.Modify(ctx, m.ModifyOptions{CPUs: 4, MemoryMiB: 4096})
if err != nil {
    return err
}
for _, r := range plan.ResizeStatus {
    fmt.Printf("%s: %s -> %s (%s)\n", r.Resource, r.Requested, r.Actual, r.State)
}

// Preview a change without applying it
preview, err := sb.Modify(ctx, m.ModifyOptions{MaxMemoryMiB: 16384, DryRun: true})
if err != nil {
    return err
}
for _, c := range preview.Changes {
    fmt.Printf("%s: %s\n", c.Field, c.Disposition)
}

// Make an env change active now by restarting
_, err = sb.Modify(ctx, m.ModifyOptions{
    Env:    map[string]string{"MODE": "prod"},
    Policy: m.ModificationPolicyRestart,
})
// Grow the managed OCI root disk offline and restart
_, err = sb.Modify(ctx, m.ModifyOptions{
    RootDiskSizeMiB: 8192,
    Policy:          m.ModificationPolicyRestart,
})

// Add or rotate a host-environment secret; restart if it is newly added
_, err = sb.Modify(ctx, m.ModifyOptions{
    Secrets: map[string]m.SecretModifySpec{
        "API_KEY": {
            Env:          "API_KEY",
            AllowedHosts: []string{"api.example.com"},
        },
    },
    Policy: m.ModificationPolicyRestart,
})

// Remove an existing secret
_, err = sb.Modify(ctx, m.ModifyOptions{
    SecretsRemove: []string{"OLD_API_KEY"},
})
```

--------------------------------

### fs.stat() example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/filesystem.mdx

Get detailed metadata for a file or directory.

```python
meta = await sb.fs.stat("/app/config.json")
print(meta.kind, meta.size, meta.readonly)
```

--------------------------------

### Build FFI shim and run examples

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/go/README.md

Build the native library and run Go examples with the FFI path configured via environment variables and build tags.

```bash
cargo build -p microsandbox-go

cd sdk/go
export MICROSANDBOX_FFI_PATH=../../target/debug/libmicrosandbox_go_ffi.dylib
go run -tags microsandbox_ffi_path ./examples/basic
```

--------------------------------

### Create a snapshot example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/snapshots.mdx

An example demonstrating how to retrieve a sandbox handle and create a snapshot named 'after-pip-install'.

```python
handle = await Sandbox.get("baseline")
snap = await handle.snapshot("after-pip-install")
print(snap.digest)
```

--------------------------------

### Verify OpenClaw version

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/openclaw.mdx

Verify the installed version of OpenClaw before removing the setup sandbox.

```sh
msb exec openclaw-setup -- openclaw --version
```

--------------------------------

### ServeConnection usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/ssh.mdx

Example showing how to prepare an SSH server and serve a connection.

```go
srv, err := sb.SSH().PrepareServer(ctx)
if err != nil {
    return err
}
defer srv.Close(ctx)

if err := srv.ServeConnection(ctx); err != nil {
    return err
}
```

--------------------------------

### SSH server initialization example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/ssh.mdx

An example showing how to prepare an SSH server with a specific authorized keys path and user, while disabling SFTP, followed by serving the connection.

```python
server = await sb.ssh().prepare_server(
    authorized_keys_path="/home/me/.ssh/authorized_keys",
    user="app",
    sftp=False,
)
await server.serve_connection()
```

--------------------------------

### Run a Python example

Source: https://github.com/superradcompany/microsandbox/blob/main/examples/python/README.md

Command to execute a specific Python example from the repository root.

```sh
uv run --project sdk/python python examples/python/<example>/main.py
```

--------------------------------

### Boot a sandbox from a host directory in Python

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/changelog/2026-06-26.mdx

Example using the Python SDK to create a sandbox that boots directly from a host directory using Image.bind.

```python
from microsandbox import Image, Sandbox

async with await Sandbox.create(
    "dev",
    image=Image.bind("/srv/rootfs/python-base"),
) as sb:
    output = await sb.exec("python", ["-c", "print('hello from bind rootfs')"])
    print(output.stdout_text)
```

--------------------------------

### Start Goose on Windows

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/goose.mdx

Initializes a microsandbox with Goose installed using the provided PowerShell command.

```powershell
msb run -t --name goose-demo --replace `
  --cpus 2 --memory 2G --root-disk 3G `
  --mount-dir ./my-project:/workspace:rw `
  --workdir /workspace `
  debian:bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates curl bzip2 git &&
    curl -fsSL https://github.com/aaif-goose/goose/releases/download/v1.44.0/download_cli.sh |
      GOOSE_BIN_DIR=/usr/local/bin GOOSE_VERSION=v1.44.0 CONFIGURE=false bash &&
    exec goose session
  '
```

--------------------------------

### Snapshot::load usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/rust/snapshots.mdx

Example demonstrating how to load a snapshot archive from a path.

```rust
use std::path::Path;

let h = Snapshot::load(Path::new("/tmp/baseline.tar.zst"), None).await?;
println!("loaded {}", h.digest());
```

--------------------------------

### Create and run a disk snapshot

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/changelog/2026-05-15.mdx

Demonstrates creating a snapshot from a sandbox and booting a new fork from that baseline.

```bash
msb snapshot create my-sandbox --name baseline
msb run alpine --from baseline --name fork
```

--------------------------------

### TypeScript Setup Builder

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Configures and executes the microsandbox installation using the TypeScript builder pattern.

```APIDOC
## TypeScript Setup Builder

### Description
Configures the installation environment using a builder pattern. Methods include `baseDir`, `version`, `skipVerify`, and `force`.

### Method
`setup().baseDir().version().skipVerify().force().install()`

### Parameters
- **baseDir** (string) - Optional - Sets the installation root directory.
- **version** (string) - Optional - Specifies the runtime version to install.
- **skipVerify** (boolean) - Optional - Toggles post-install verification.
- **force** (boolean) - Optional - Forces a download even if files exist.
```

--------------------------------

### CreateSandbox(ctx context.Context, name string, opts ...SandboxOption) (*Sandbox, error)

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/sandbox.mdx

Creates and boots a new sandbox. It pulls the image, boots the VM, starts the guest agent, and waits until it is ready to accept commands.

```APIDOC
## CreateSandbox

### Description
Creates and boots a new sandbox. Pulls the image if needed, boots the VM, starts the guest agent, and waits until it is ready to accept commands.

### Parameters
- **ctx** (context.Context) - Required - Cancels the boot operation only.
- **name** (string) - Required - Sandbox name, up to 128 UTF-8 bytes.
- **opts** (...SandboxOption) - Optional - Functional options applied in order.

### Returns
- ***Sandbox** - Running sandbox instance.
- **error** - Typed *Error if the operation fails.
```

--------------------------------

### Start Goose on macOS & Linux

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/goose.mdx

Initializes a microsandbox with Goose installed using the provided shell command.

```sh
msb run -t --name goose-demo --replace \
  --cpus 2 --memory 2G --root-disk 3G \
  --mount-dir ./my-project:/workspace:rw \
  --workdir /workspace \
  debian:bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates curl bzip2 git &&
    curl -fsSL https://github.com/aaif-goose/goose/releases/download/v1.44.0/download_cli.sh |
      GOOSE_BIN_DIR=/usr/local/bin GOOSE_VERSION=v1.44.0 CONFIGURE=false bash &&
    exec goose session
  '
```

--------------------------------

### msb create command examples

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/cli/sandbox-commands.mdx

Create and boot a sandbox with specified resources or replacement policies. Note that certain host-integrated features are limited when running on the microsandbox cloud.

```bash
msb create python --name worker -c 2 -m 1G
msb create --replace python --name worker            # Replace existing
msb create --replace-with-timeout 30s python --name worker  # Give the old one 30s to exit
msb create --replace-with-timeout 0 python --name worker    # SIGKILL immediately
```

--------------------------------

### Execute CLI commands with a configuration file

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/cli/configuration.mdx

Examples of using the --conf flag with run, create, and install commands.

```bash
msb run --conf sandbox.yaml -- start
msb create --conf sandbox.yaml --name agent
msb install --conf sandbox.yaml --name agent
```

--------------------------------

### Retrieve Sandbox Metrics Example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/sandbox.mdx

Example showing how to retrieve and print current CPU and memory usage.

```go
metrics, err := sb.Metrics(ctx)
fmt.Printf("cpu %.1f%% · mem %d MiB\n",
    metrics.CPUPercent, metrics.MemoryBytes/(1<<20))
```

--------------------------------

### Run SDK Example

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/python/README.md

Command to execute a specific Python example from the repository root using the SDK project.

```bash
uv run --project sdk/python python examples/python/root-oci/main.py
```

--------------------------------

### Lifecycle and backend example commands

Source: https://github.com/superradcompany/microsandbox/blob/main/examples/rust/README.md

Commands to run lifecycle convergence and cloud backend examples.

```sh
cargo run -p lifecycle-convergence
cargo run -p cloud-backend
```

--------------------------------

### Define and execute scripts in Rust

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sandboxes/bootstrap.mdx

Uses the Sandbox builder with the indoc macro to define setup and start scripts, then executes them asynchronously.

```rust
use indoc::indoc;
use microsandbox::Sandbox;

let sb = Sandbox::builder("worker")
    .image("ubuntu")
    .script("setup", indoc! {"
        #!/bin/bash
        apt-get update && apt-get install -y python3 curl
    "})
    .script("start", indoc! {"
        #!/bin/bash
        exec python3 /app/main.py
    "})
    .create()
    .await?;

sb.shell("setup").await?;
let output = sb.shell("start").await?;
```

--------------------------------

### Create and boot from a sandbox snapshot

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sandboxes/snapshots.mdx

This workflow demonstrates stopping a running sandbox, creating a snapshot of its state, and booting a new sandbox from that snapshot.

```bash
# 1. Boot a sandbox, install state, then stop it
msb run --name baseline --detach python:3.12
msb exec baseline -- pip install requests
msb stop baseline

# 2. Snapshot the stopped sandbox
msb snapshot create after-pip-install --from baseline

# 3. Boot a fresh sandbox from the snapshot
msb run --name worker --from-snapshot after-pip-install \
    -- python -c "import requests; print(requests.__version__)"
```

--------------------------------

### Reusable Lifecycle Convergence

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/go/README.md

Use ConnectOrCreateSandbox to manage persistent sandboxes by name. This example shows connecting to a sandbox, starting it, stopping it, and restarting it.

```go
sb, err := microsandbox.ConnectOrCreateSandbox(ctx, "worker",
    microsandbox.WithImage("python"),
    microsandbox.WithMemory(1024),
)

fmt.Printf("%s: %s\n", sb.Name(), sb.ID())
handle, err := microsandbox.GetSandbox(ctx, "worker")
running, err := handle.ConnectOrStart(ctx)
err = running.RequestStop(ctx)
stopped, err := running.WaitForStatus(ctx, microsandbox.SandboxStatusStopped)
restarted, err := stopped.Restart(ctx)
err = restarted.Destroy(ctx)
```

--------------------------------

### Minimal example in Python

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/getting-started/introduction.mdx

Create a sandbox using the Python image and execute a print command.

```python
from microsandbox import Sandbox

sb = await Sandbox.create("hello", image="python")

output = await sb.exec("python", ["-c", "print('Hello from a microVM!')"])
print(output.stdout_text)

await sb.stop()
```

--------------------------------

### Start Gemini CLI on macOS & Linux

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/gemini-cli.mdx

Initializes a microsandbox with a writable host-directory mount and installs the Gemini CLI. This command is for local-only use.

```sh
msb run -t --name gemini-demo --replace \
  --cpus 2 --memory 2G --root-disk 4G \
  --mount-dir ./my-project:/workspace:rw \
  --workdir /workspace \
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @google/gemini-cli@0.52.0 &&
    exec gemini
  '
```

--------------------------------

### Start Codex CLI in a microVM

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/codex.mdx

Initializes a microsandbox with the specified resources and installs the pinned Codex CLI version. Replace ./my-project with your local directory path.

```sh
msb run -t --name codex-demo --replace \
  --cpus 2 --memory 2G --root-disk 4G \
  --mount-dir ./my-project:/workspace:rw \
  --workdir /workspace \
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @openai/codex@0.148.0 &&
    exec codex
  '
```

```powershell
msb run -t --name codex-demo --replace `
  --cpus 2 --memory 2G --root-disk 4G `
  --mount-dir ./my-project:/workspace:rw `
  --workdir /workspace `
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @openai/codex@0.148.0 &&
    exec codex
  '
```

--------------------------------

### Manage Reusable Sandbox Lifecycle

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/node-ts/README.md

Use connectOrCreate to converge on a persisted sandbox by name. This example demonstrates connecting, starting, stopping, restarting, and destroying a sandbox instance.

```typescript
const sandbox = await Sandbox.builder("worker")
  .image("python")
  .memory(MiB(1024))
  .connectOrCreate();

console.log(`${sandbox.name}: ${sandbox.id}`);
const running = await (await Sandbox.get("worker")).connectOrStart();
await running.requestStop();
const stopped = await running.waitForStatus("stopped");
const restarted = await stopped.restart();
await restarted.destroy();
```

--------------------------------

### Create a sandbox with a VSock route

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/vsock.mdx

This example demonstrates how to configure a sandbox with a VSock route using m.WithVsock during sandbox creation.

```go
sandbox, err := m.CreateSandbox(ctx, "worker",
    m.WithImage("alpine"),
    m.WithVsock(m.VsockRoute{
        HostSocket: "/run/host-api.sock",
        Port:       5000,
    }),
)
```

--------------------------------

### Creating a snapshot example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/typescript/snapshots.mdx

An example showing how to stop a sandbox and create a snapshot named 'after-pip-install'.

```typescript
const h = await Sandbox.get("baseline");
await h.stop();
const snap = await h.snapshot("after-pip-install");
```

--------------------------------

### Start Pi agent

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/pi.mdx

Initializes the Pi coding agent in a microsandbox container with writable host-directory access. The command installs the agent via npm and executes it within the workspace.

```sh
msb run -t --name pi-demo --replace \
  --cpus 2 --memory 2G --root-disk 4G \
  --mount-dir ./my-project:/workspace:rw \
  --workdir /workspace \
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @mariozechner/pi-coding-agent@0.73.1 &&
    exec pi
  '
```

```powershell
msb run -t --name pi-demo --replace `
  --cpus 2 --memory 2G --root-disk 4G `
  --mount-dir ./my-project:/workspace:rw `
  --workdir /workspace `
  node:24-bookworm-slim -- sh -lc '
    apt-get update &&
    apt-get install -y --no-install-recommends ca-certificates git &&
    npm install -g @mariozechner/pi-coding-agent@0.73.1 &&
    exec pi
  '
```

--------------------------------

### fs.mkdir() example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/filesystem.mdx

Create a directory, including any missing parent directories.

```python
await sb.fs.mkdir("/app/data/cache")
```

--------------------------------

### Modifying sandbox configuration examples

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/sandbox.mdx

Examples demonstrating live resizing, dry runs, environment updates, disk resizing, and secret management.

```python
from microsandbox import (
    ModificationDisposition,
    ModificationPolicy,
    ResourceConvergenceState,
)

# Live resize: applies to the running VM when within the booted capacity
plan = await sb.modify(cpus=4, memory=4096)
for r in plan.get("resize_status", []):
    if r["state"] is ResourceConvergenceState.APPLIED:
        print(f'{r["resource"]}: {r["requested"]} -> {r["actual"]}')

# Preview a change without applying it
plan = await sb.modify(max_memory=16384, dry_run=True)
for change in plan["changes"]:
    if change["disposition"] is ModificationDisposition.REQUIRES_RESTART:
        print(f'{change["field"]} needs a restart')

# Make an env change active now by restarting
await sb.modify(env={"MODE": "prod"}, policy=ModificationPolicy.RESTART)

# Grow the managed OCI root disk offline and restart
await sb.modify(root_disk_size=8192, policy=ModificationPolicy.RESTART)

# Add or rotate a host-environment secret; restart if it is newly added
await sb.modify(
    secrets={
        "API_KEY": {
            "env": "API_KEY",
            "allowed_hosts": ["api.example.com"],
        },
    },
    policy=ModificationPolicy.RESTART,
)

# Remove an existing secret
await sb.modify(secrets_rm=["OLD_API_KEY"])
```

--------------------------------

### Perform a dry run modification

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sandboxes/tuning.mdx

Use these examples to preview configuration changes without applying them. The planner will classify the requested fields as live, next start, requires restart, or unsupported.

```bash
msb modify worker --max-memory 16G --dry-run
```

```typescript
const plan = await sandbox.modify({
  maxMemory: 16_384,
  dryRun: true,
});
```

```rust
let plan = sb.modify()
    .max_memory(16_384)
    .dry_run()
    .await?;
```

```python
plan = await sb.modify(max_memory=16_384, dry_run=True)
```

```go
plan, err := sb.Modify(ctx, m.ModifyOptions{
    MaxMemoryMiB: 16_384,
    DryRun:        true,
})
```

--------------------------------

### msb modify command examples

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/cli/sandbox-commands.mdx

Use msb modify to change a running sandbox's configuration. Changes are applied as an all-or-nothing plan, with options for live resizing, restarts, or scheduling changes for the next start.

```bash
msb modify api --cpus 4                     # Live when 4 <= max_cpus
msb modify api --env MODE=prod --restart    # Restart to apply now
msb modify api --max-memory 16G --next-start # Raise the ceiling on next start
msb modify api --cpus 8 --dry-run           # Show the plan, apply nothing
```

--------------------------------

### Runtime Installation and Verification

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Methods to check if the microsandbox runtime is installed and to perform an installation if it is missing.

```APIDOC
## Runtime Setup Methods

### Description
These methods allow developers to verify the presence of the required runtime environment and trigger an installation if necessary. These operations are idempotent.

### Methods
- **isInstalled()** (boolean) - Returns true if the runtime is correctly installed.
- **install()** (void/Result) - Downloads and verifies the pinned runtime for the SDK.

### SDK Specific Signatures
- **TypeScript**: `isInstalled(): boolean`, `install(): Promise<void>`
- **Rust**: `setup::is_installed() -> bool`, `setup::install() -> MicrosandboxResult<()>`
- **Python**: `is_installed() -> bool`, `install() -> Awaitable[None]`
- **Go**: `IsInstalled() bool`, `EnsureInstalled(ctx, ...SetupOption) error`
- **Ruby**: `Microsandbox.installed?`, `Microsandbox.install`
```

--------------------------------

### Boot database from snapshot

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/data/migration-rehearsal.mdx

Boot a fresh database instance from the previously created snapshot.

```sh
msb run -d --name migration-test --replace \
  --from-snapshot postgres-before-migration \
  --memory 1G \
  -p 127.0.0.1:55432:5432 \
  -e POSTGRES_PASSWORD="$POSTGRES_PASSWORD" \
  -e POSTGRES_DB=examples \
  -e DOCKER_PG_LLVM_DEPS=
```

```powershell
msb run -d --name migration-test --replace `
  --from-snapshot postgres-before-migration `
  --memory 1G `
  -p 127.0.0.1:55432:5432 `
  -e "POSTGRES_PASSWORD=$env:POSTGRES_PASSWORD" `
  -e POSTGRES_DB=examples `
  -e DOCKER_PG_LLVM_DEPS=
```

--------------------------------

### Install and verify runtime in Python

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Checks for the runtime installation and performs an asynchronous install if necessary.

```python
from microsandbox import install, is_installed

if not is_installed():
    await install()
```

--------------------------------

### Configure Network, DNS, and Ports

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/go/README.md

Demonstrates creating sandboxes with isolated networks, filtered domain access, custom DNS, and port mapping.

```go
isolated, err := microsandbox.CreateSandbox(ctx, "go-readme-isolated",
    microsandbox.WithImage("alpine:3.19"),
    microsandbox.WithNetwork(microsandbox.NetworkPolicy.None()),
    microsandbox.WithReplace(),
)
if err != nil {
    log.Fatal(err)
}
defer isolated.Close()

filtered, err := microsandbox.CreateSandbox(ctx, "go-readme-filtered",
    microsandbox.WithImage("alpine:3.19"),
    microsandbox.WithNetwork(&microsandbox.NetworkConfig{
        DenyDomains:        []string{"blocked.example.com"},
        DenyDomainSuffixes: []string{".evil.com"},
        DNS: &microsandbox.DNSConfig{
            Nameservers: []string{"1.1.1.1:53"},
        },
    }),
    microsandbox.WithReplace(),
)
if err != nil {
    log.Fatal(err)
}
defer filtered.Close()

web, err := microsandbox.CreateSandbox(ctx, "go-readme-web",
    microsandbox.WithImage("python:3.12"),
    microsandbox.WithPorts(map[uint16]uint16{8080: 80}),
    microsandbox.WithReplace(),
)
```

--------------------------------

### Install and verify runtime in TypeScript

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/setup.mdx

Checks if the runtime is installed and installs it if missing using the microsandbox package.

```typescript
import { install, isInstalled } from "microsandbox";

if (!isInstalled()) {
  await install();
}
```

--------------------------------

### Sandbox.builder().image()

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/images/overview.mdx

Configures a sandbox to boot from a local disk image file. The system auto-detects the format based on the file extension (.qcow2, .raw, .vmdk).

```APIDOC
## Sandbox.builder().image(path)

### Description
Sets the disk image source for the sandbox. The system automatically detects the format from the file extension.

### Parameters
- **path** (string) - Required - The local file path to the disk image (e.g., ./ubuntu.qcow2).
```

--------------------------------

### Install microsandbox

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/troubleshooting/macos.mdx

Run the installer script to set up the microsandbox CLI. Open a new terminal after installation if the PATH has been updated.

```bash
curl -fsSL https://install.microsandbox.dev | sh
```

--------------------------------

### Full global configuration example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/configuration.mdx

A comprehensive example of the ~/.microsandbox/config.json file, including settings for database, paths, sandbox defaults, runtime, registries, SSH, metrics, and profiles.

```json
{
  "home": "/custom/path/.microsandbox",
  "log_level": "info",
  "deployment_profile": "multi-tenant",
  "database": {
    "url": "sqlite:///tmp/msb.db",
    "max_connections": 10,
    "connect_timeout_secs": 30,
    "busy_timeout_secs": 30
  },
  "paths": {
    "msb": "/usr/local/bin/msb",
    "libkrunfw": "/usr/local/lib/libkrunfw.so",
    "cache": "/mnt/fast/msb-cache",
    "sandboxes": null,
    "volumes": null,
    "snapshots": null,
    "logs": null,
    "secrets": null
  },
  "sandbox_defaults": {
    "cpus": 2,
    "memory_mib": 1024,
    "cpu_placement": "auto",
    "placement_profile": "latency",
    "thp": "madvise",
    "oci": {
      "root_disk": {
        "kind": "flat",
        "size_mib": 8192,
        "clone": "auto"
      }
    },
    "shell": "/bin/bash",
    "workdir": "/app"
  },
  "runtime": {
    "placement_profiles": {
      "latency": {
        "numa": { "mode": "prefer_single" },
        "memory": { "mode": "follow_cpu" }
      }
    },
    "block_writeback": {
      "mode": "auto"
    }
  },
  "registries": {
    "ca_certs": "/path/to/corporate-ca.pem",
    "hosts": {
      "ghcr.io": {
        "auth": {
          "username": "octocat",
          "store": "keyring"
        }
      },
      "registry.example.com": {
        "insecure": true,
        "auth": {
          "username": "deploy",
          "password_env": "REGISTRY_TOKEN"
        }
      },
      "docker.io": {
        "auth": {
          "username": "user",
          "secret_name": "dockerhub-token"
        }
      }
    }
  },
  "ssh": {
    "inactivity_timeout_secs": 600
  },
  "metrics": {
    "capacity": 4096
  },
  "active_profile": "prod",
  "profiles": {
    "prod": {
      "backend": "cloud",
      "api_key_ref": "env:MSB_API_KEY"
    },
    "local": {
      "backend": "local"
    }
  }
}
```

--------------------------------

### Ensure SDK Installation

Source: https://github.com/superradcompany/microsandbox/blob/main/sdk/go/README.md

Call EnsureInstalled at process startup to verify or set up the required runtime components. This operation is idempotent.

```go
if err := microsandbox.EnsureInstalled(ctx); err != nil {
    log.Fatalf("microsandbox setup: %v", err)
}
```

--------------------------------

### SandboxHandle.connect_or_start()

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/sandbox.mdx

Connects to the sandbox if running, waits if starting, or starts it if it is in a compatible state. Detached mode only affects local starts.

```python
async def connect_or_start(self, *, detached: bool = False) -> Sandbox
```

--------------------------------

### ssh.server() usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/rust/ssh.mdx

Example showing how to initialize and serve an SSH server using convenience defaults.

```rust
let server = sb.ssh().server().await?;
let (client_io, server_io) = tokio::io::duplex(64 * 1024);
server.serve(server_io).await?;
```

--------------------------------

### Install package

Source: https://github.com/superradcompany/microsandbox/blob/main/packages/microsandbox-types/typescript/README.md

Install the package as a dependency in your project.

```bash
npm install @microsandbox/types
```

--------------------------------

### Mount.Bind() example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/volumes.mdx

Examples of binding host paths with read-only access and specific storage quotas.

```go
"/host": m.Mount.Bind("/var/data", m.MountOptions{Readonly: true})
"/out":  m.Mount.Bind("./output", m.MountOptions{QuotaMiB: 2048})
```

--------------------------------

### Minimal example in Ruby

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/getting-started/introduction.mdx

Create a sandbox using the Python image and execute a print command.

```ruby
require "microsandbox"

Microsandbox::Sandbox.with("hello", image: "python") do |sb|
  output = sb.exec("python", ["-c", "print('Hello from a microVM!')"])
  puts output.stdout
end
```

--------------------------------

### Volume::remove() example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/rust/volumes.mdx

Example of removing a volume by name.

```rust
Volume::remove("pip-cache").await?;
```

--------------------------------

### msb create

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/cli/sandbox-commands.mdx

Boots an idle sandbox for later execution.

```APIDOC
## msb create

### Description
Boot an idle sandbox for later exec calls.

### Parameters
- **--name** (string) - Required - The name of the sandbox to create.
```

--------------------------------

### sb.request_stop() usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/sandbox.mdx

Example of requesting a graceful shutdown.

```python
await sb.request_stop()
```

--------------------------------

### sb.shell() example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/rust/execution.mdx

Example of running a shell command with pipes.

```rust
let out = sb.shell("cat /etc/os-release | grep PRETTY_NAME").await?;
println!("{}", out.stdout()?);
```

--------------------------------

### Sandbox.create() usage

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/sandbox.mdx

Example of creating and booting a sandbox using an async context manager. Local sandboxes are automatically cleaned up on exit.

```python
async with await Sandbox.create("my-sandbox", image="alpine") as sb:
    output = await sb.shell("echo hello")
    print(output.stdout_text)
# Local sandbox is automatically killed and removed on exit
```

--------------------------------

### Snapshot.Create() usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/snapshots.mdx

Example of creating a snapshot with specific options including name, source sandbox, and labels.

```go
snap, err := m.Snapshot.Create(ctx, m.SnapshotCreateOptions{
    Name:            "after-pip-install",
    FromSandbox:     "baseline",
    Labels:          map[string]string{"stage": "post-deps"},
    RecordIntegrity: true,
})
```

--------------------------------

### Mount.Named() example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/volumes.mdx

Example of mounting a named persistent volume.

```go
"/data": m.Mount.Named("my-data", m.MountOptions{})
```

--------------------------------

### CreateSandbox usage example

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/go/sandbox.mdx

Example of creating a sandbox with specific image, memory, CPU, and environment configurations, including cleanup logic.

```go
sb, err := m.CreateSandbox(ctx, "api",
    m.WithImage("python:3.12"),
    m.WithMemory(512),
    m.WithCPUs(2),
    m.WithEnv(map[string]string{"PYTHONDONTWRITEBYTECODE": "1"}),
)
if err != nil {
    return err
}
defer func() {
    _ = sb.Stop(context.Background())
    _ = sb.Close()
}()
```

--------------------------------

### Verify the installation

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/opencode.mdx

Checks the installed version of OpenCode within the sandbox.

```sh
msb exec opencode-demo -- opencode --version
```

--------------------------------

### Install and Uninstall Sandboxes

Source: https://github.com/superradcompany/microsandbox/blob/main/README.md

Installs a sandbox as a command and removes it when finished.

```sh
msb install ubuntu               # Install ubuntu sandbox as 'ubuntu' command
ubuntu                           # Opens Ubuntu in a microVM
msb uninstall ubuntu             # Uninstall the ubuntu sandbox
```

--------------------------------

### Create the sandbox

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/data/juicefs-s3.mdx

Initialize the Ubuntu sandbox with the necessary scripts and configuration files.

```sh
msb create ubuntu:24.04 \
  --name juicefs-s3-demo \
  --replace \
  --cpus 2 \
  --memory 2G \
  --root-disk 6G \
  --copy-file ./juicefs-s3.env:/root/juicefs-s3.env \
  --script-path mount-juicefs:./mount-juicefs.sh \
  --script-path test-juicefs:./test-juicefs.sh \
  --script-path remount-juicefs:./remount-juicefs.sh \
  --script-path cleanup-juicefs:./cleanup-juicefs.sh
```

```powershell
msb create ubuntu:24.04 `
  --name juicefs-s3-demo `
  --replace `
  --cpus 2 `
  --memory 2G `
  --root-disk 6G `
  --copy-file ./juicefs-s3.env:/root/juicefs-s3.env `
  --script-path mount-juicefs:./mount-juicefs.sh `
  --script-path test-juicefs:./test-juicefs.sh `
  --script-path remount-juicefs:./remount-juicefs.sh `
  --script-path cleanup-juicefs:./cleanup-juicefs.sh
```

--------------------------------

### Follow container logs

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/development/vnc-desktop.mdx

Monitor the installation and service startup process.

```sh
msb logs -f vnc-desktop
```

--------------------------------

### Verify the installation

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/examples/agents/goose.mdx

Checks the installed version of Goose within the sandbox.

```sh
msb exec goose-demo -- goose --version
```

--------------------------------

### handle.start()

Source: https://github.com/superradcompany/microsandbox/blob/main/docs/sdk/python/sandbox.mdx

Start the sandbox in either attached or detached mode.

```APIDOC
## handle.start()

### Description
Start the sandbox in attached or detached mode.

### Parameters
- **detached** (bool) - Optional - Whether to start in detached mode.
```
Tokens:
Raw