> ## Documentation Index
> Fetch the complete documentation index at: https://docs.celesto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# CLI overview

> Overview of the Celesto command-line interface for creating sandboxes, opening shells, managing snapshots, starting the HTTP server, and launching browser or desktop sessions.

The Celesto CLI lets you create and manage disposable computers from your terminal. Use it when you want to start a sandbox, open a shell, move files, expose a local port, or run the dashboard without writing Python code.

## Install

Install the base CLI:

```bash theme={null}
pip install celesto
```

Install the dashboard and HTTP server dependencies:

```bash theme={null}
pip install "celesto[dashboard]"
```

## Command groups

| Command                    | What you can do                                                                                                                            |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `celesto sandbox`          | Create, inspect, start, stop, pause, resume, connect to, and delete sandboxes; open macOS desktops with `sandbox desktop`                  |
| `celesto sandbox exec`     | Run one command inside a running sandbox from a script or agent                                                                            |
| `celesto sandbox logs`     | Show a sandbox's host boot and console log                                                                                                 |
| `celesto sandbox snapshot` | Save and restore sandbox state                                                                                                             |
| `celesto sandbox file`     | Copy files into or out of a sandbox                                                                                                        |
| `celesto sandbox env`      | Set, remove, and list sandbox environment variables                                                                                        |
| `celesto sandbox port`     | Share a sandbox port on `127.0.0.1`                                                                                                        |
| `celesto openclaw`         | Create and list OpenClaw sandboxes; open the browser dashboard with `open-ui` ([guide](/smolvm/features/coding-agents#work-with-openclaw)) |
| `celesto browser`          | Start browser and desktop-style browser sessions                                                                                           |
| `celesto windows`          | Build a reusable Windows 11 `qcow2` image                                                                                                  |
| `celesto server`           | Start the local Celesto HTTP API                                                                                                           |
| `celesto ui`               | Start the local dashboard                                                                                                                  |
| `celesto bridge`           | Check host Linux bridges before using [bridged networking](/smolvm/features/bridged-networking)                                            |
| `celesto completion`       | Install shell tab completion for `bash`, `zsh`, or `fish`                                                                                  |
| `celesto doctor`           | Check whether your host can run Celesto                                                                                                    |
| `celesto update`           | Upgrade Celesto to the latest stable release                                                                                               |
| `celesto image`            | Pull, list, inspect, build, save, load, and prune cached sandbox images                                                                    |
| `celesto images`           | Alias of `celesto image list`                                                                                                              |
| `celesto prune`            | Alias of `celesto image prune` — remove image caches from older releases                                                                   |

## Everyday sandbox workflow

Create a sandbox, open the fast shell, then stop it when you are done:

```bash theme={null}
celesto sandbox create --name my-sandbox
celesto sandbox shell my-sandbox
celesto sandbox stop my-sandbox
```

Use SSH when you specifically need a real SSH session:

```bash theme={null}
celesto sandbox ssh my-sandbox
```

List your sandboxes:

```bash theme={null}
celesto sandbox list --all
```

Run a single command in a sandbox from a script or agent — the guest's exit code becomes `celesto`'s exit code:

```bash theme={null}
celesto sandbox exec my-sandbox -- python --version
```

Read the host boot and console log when something goes wrong at startup:

```bash theme={null}
celesto sandbox logs my-sandbox --follow
```

## macOS desktop workflow

On an Apple Silicon Mac, create a disposable macOS environment:

```bash theme={null}
celesto sandbox create --os macos --name nimble-mac
```

The create output confirms that the sandbox is running and includes the next command:

```text theme={null}
Next: celesto sandbox desktop nimble-mac
Info: celesto sandbox info nimble-mac
```

Run the `Next` command to open the sandbox in Screen Sharing:

```bash theme={null}
celesto sandbox desktop nimble-mac
```

```text theme={null}
Opened the desktop for sandbox 'nimble-mac'.
```

The first run prepares a reusable local image. See [Disposable macOS environments](/smolvm/guides/macos-sandboxes) for the one-time setup, requirements, and full create output.

## Tab completion

Turn on tab completion so your shell can finish `celesto` commands, options, and the names of your existing sandboxes:

```bash theme={null}
celesto completion bash --install   # also: zsh, fish
```

See [`celesto completion`](/smolvm/cli/completion) for the manual setup and per-shell details.

## Snapshot workflow

Create a checkpoint before a risky change, then restore it later:

```bash theme={null}
celesto sandbox snapshot create my-sandbox --snapshot-id before-change --resume-source
celesto sandbox snapshot restore before-change --resume
```

## File, env, and port workflow

Copy files, set environment variables, and expose a sandbox service:

```bash theme={null}
celesto sandbox file upload my-sandbox ./prompt.txt /workspace/prompt.txt
celesto sandbox env set my-sandbox MODEL=gpt-4.1
celesto sandbox port expose my-sandbox 8080:3000
```

## Browser workflow

Start a browser sandbox with a live viewer:

```bash theme={null}
celesto browser start --live --json
```

The JSON response includes the session ID and viewer URLs. Use the session ID with other browser commands:

```bash theme={null}
celesto browser list
celesto browser open <session_id>
celesto browser stop <session_id>
```

## HTTP API workflow

Start the local API server when you want another process, script, or TypeScript client to manage Celesto:

```bash theme={null}
celesto server start --host 127.0.0.1 --port 8000
```

See [HTTP API and TypeScript SDK](/smolvm/guides/http-api-typescript-sdk) for endpoint and client examples.

## Getting help

Display help for the main command:

```bash theme={null}
celesto --help
```

Display help for a subcommand:

```bash theme={null}
celesto sandbox create --help
celesto sandbox snapshot create --help
celesto server start --help
```

## Next steps

<CardGroup cols={2}>
  <Card title="Create a sandbox" icon="plus" href="/smolvm/cli/create">
    Start a Linux, macOS, or Windows sandbox from the CLI
  </Card>

  <Card title="Open a shell" icon="terminal" href="/smolvm/cli/shell">
    Use the fast shell or an SSH session
  </Card>

  <Card title="Copy files" icon="file-up" href="/smolvm/cli/file">
    Move files into and out of a sandbox
  </Card>

  <Card title="Snapshots" icon="camera" href="/smolvm/cli/snapshot">
    Save and restore sandbox state
  </Card>

  <Card title="HTTP API" icon="server" href="/smolvm/cli/server">
    Run the local API server
  </Card>

  <Card title="Dashboard UI" icon="panel-top" href="/smolvm/cli/ui">
    Launch the dashboard interface
  </Card>
</CardGroup>


## Related topics

- [celesto completion](/smolvm/cli/completion.md)
- [celesto windows](/smolvm/cli/windows.md)
- [Celesto architecture overview](/smolvm/concepts/overview.md)
- [SSHClient](/smolvm/api/sshclient.md)
- [Agent-to-Agent (A2A) Protocol](/agentor/concepts/a2a-protocol.md)
