# Control plane
Source: https://docs.boxd.sh/access/control-plane
Manage machines and run commands remotely via SSH.
The control plane is your remote interface to boxd. You interact with it by SSHing to `boxd.sh`.
## Single commands
Pass any command directly:
```bash theme={"theme":"github-dark"}
ssh boxd.sh new --name=myapp
ssh boxd.sh list
ssh boxd.sh exec myapp -- uname -a
ssh boxd.sh destroy myapp
```
This is the best mode for automation and coding agents.
## Interactive shell
SSH without a command to get the `boxd>` prompt:
```bash theme={"theme":"github-dark"}
ssh boxd.sh
```
```
boxd -- your cloud, your rules
Type 'help' for available commands.
boxd> list
name status ip image
myapp running 5.135.42.17 default
boxd> exec myapp -- hostname
myapp
boxd> exit
goodbye
```
## Running commands inside machines
Use `exec` to run commands inside a machine:
```bash theme={"theme":"github-dark"}
ssh boxd.sh exec myapp -- ls /home
ssh boxd.sh exec myapp -- sudo apt install -y nodejs
ssh boxd.sh exec myapp -- "cd /app && python3 server.py"
```
Commands run as the `boxd` user, which has passwordless sudo. The working directory is `/home/boxd`.
For interactive commands (editors, REPLs), add `--tty`:
```bash theme={"theme":"github-dark"}
ssh boxd.sh exec myapp --tty -- bash
```
## Connecting interactively
`connect` opens a full interactive shell session inside a machine:
```bash theme={"theme":"github-dark"}
ssh boxd.sh connect myapp
```
This drops you into a login shell as the `boxd` user. Use this for interactive work -- editing files, running a REPL, debugging.
`connect` requires a terminal with PTY support. For automation, use `exec` instead.
## Managing proxies
Every machine gets a default proxy at `name.boxd.sh` forwarding to port 8000. You can change the port and create additional subdomain proxies.
```bash theme={"theme":"github-dark"}
# List proxies for a machine
ssh boxd.sh proxy list --vm=myapp
# Change the default proxy port
ssh boxd.sh proxy set-port --vm=myapp --port=3000
# Auto-detect listening port for the default proxy
ssh boxd.sh proxy set-port --vm=myapp --port=auto
# Create a subdomain proxy: api.myapp.boxd.sh -> port 3001
ssh boxd.sh proxy new api --vm=myapp --port=3001
# Change a named proxy's port
ssh boxd.sh proxy set-port api --vm=myapp --port=3002
# Remove a proxy
ssh boxd.sh proxy delete api --vm=myapp
```
The `--vm` flag is required for `proxy new`, `proxy delete`, and `proxy set-port` via SSH. For `proxy list`, `--vm` is optional — omit it to list all proxies. Inside a VM, the `boxd` CLI defaults to the current machine for all proxy commands.
## JSON output
Add `--json` to any command for structured output:
```bash theme={"theme":"github-dark"}
ssh boxd.sh list --json
```
```json theme={"theme":"github-dark"}
[
{
"name": "myapp",
"vm_id": "9645b1e8-193d-4d11-86b1-f91deff5bbfb",
"status": "running",
"ip": "5.135.42.17",
"image": "default"
}
]
```
## Identity
Check your account details:
```bash theme={"theme":"github-dark"}
ssh boxd.sh whoami
```
```
user: a1b2c3d4-...
worker: worker-01
keys: SHA256:...
```
# Direct SSH
Source: https://docs.boxd.sh/access/direct-ssh
SSH directly into your machine using its public IP.
Every machine gets a unique public IPv4 address. SSH directly into it:
```bash theme={"theme":"github-dark"}
ssh root@5.135.42.17
```
You land in a shell as the `boxd` user (the SSH username is ignored for authentication -- only your public key matters).
## How it works
When you SSH to a machine's public IP, the boxd proxy:
1. Reads your SSH public key
2. Verifies you own the machine at that IP
3. Opens a session to the machine on your behalf
All standard SSH features work through the proxy:
* **SCP** -- copy files to/from the machine
* **Port forwarding** -- tunnel ports through SSH
* **VS Code Remote SSH** -- develop remotely
* **rsync** -- sync files over SSH
## When to use direct SSH
| Method | Best for |
| ------------------------------------------ | ------------------------------------------------------- |
| **HTTPS** (`name.boxd.sh`) | Serving web traffic |
| **Control plane** (`ssh boxd.sh exec ...`) | Automation, running commands remotely |
| **Direct SSH** (`ssh root@ip`) | Interactive development, file transfer, port forwarding |
## Finding your machine's IP
```bash theme={"theme":"github-dark"}
ssh boxd.sh list
```
```
name status ip image
myapp running 5.135.42.17 default
```
With JSON output:
```bash theme={"theme":"github-dark"}
ssh boxd.sh list --json
```
Direct SSH only works for the machine owner. Your SSH key must match the key registered to the account that created the machine.
# HTTPS
Source: https://docs.boxd.sh/access/https
Every machine gets an HTTPS domain automatically.
Every machine gets a domain at `name.boxd.sh`. The boxd proxy terminates TLS and forwards HTTP requests to your machine.
```
https://myapp.boxd.sh -> your machine, port 8000 (default)
```
## Getting started
nginx is pre-installed and configured on port 8000, but disabled by default. Start it:
```bash theme={"theme":"github-dark"}
ssh boxd.sh exec myapp -- sudo systemctl start nginx
```
Visit `https://myapp.boxd.sh` -- you will see a welcome page.
## Running your own app
Any process that listens on the proxy's target port (8000 by default) is reachable via HTTPS. No configuration needed.
```bash theme={"theme":"github-dark"}
# Python
ssh boxd.sh exec myapp -- python3 -m http.server 8000
# Go
ssh boxd.sh exec myapp -- "/home/boxd/app/server -port 8000"
```
Node.js is not pre-installed. Install it first: `sudo apt install -y nodejs npm` or use [nvm](https://github.com/nvm-sh/nvm).
## Changing the port
The default proxy forwards to port 8000, but you can change it:
```bash theme={"theme":"github-dark"}
# From outside
ssh boxd.sh proxy set-port --vm=myapp --port=3000
# From inside the VM
boxd proxy set-port --port=3000
# Auto-detect the listening port
boxd proxy set-port --port=auto
```
## Subdomain proxies
Create additional subdomains pointing to different ports:
```bash theme={"theme":"github-dark"}
# api.myapp.boxd.sh -> port 3001
ssh boxd.sh proxy new api --vm=myapp --port=3001
# List all proxies
ssh boxd.sh proxy list --vm=myapp
# Remove a proxy
ssh boxd.sh proxy delete api --vm=myapp
```
## WebSockets
WebSocket connections work transparently. The proxy detects the `Upgrade: websocket` header and forwards the connection.
## HTTP to HTTPS
Plain HTTP requests to `http://name.boxd.sh` are redirected to HTTPS automatically. HSTS headers are included in the response.
## DNS
A DNS record is created automatically when your machine boots. The record has a 60-second TTL.
```
myapp.boxd.sh -> A record -> machine's public IP
```
## Primitives
Create, configure, and manage VMs.
Branch an entire machine in seconds.
Automatic and custom domain routing.
Freeze and wake machines in milliseconds.
# Overview
Source: https://docs.boxd.sh/index
Instant cloud computers you can fork. SSH in, build, it's live.
If you are an agent reading this doc, visit [llms.txt](https://azin.mintlify.app/llms.txt), [llms-full.txt](https://azin.mintlify.app/llms-full.txt), or [skill.md](https://azin.mintlify.app/skill.md) instead.
boxd gives you full Linux computers in the cloud that boot in milliseconds. Every machine gets its own public IP, persistent disk, and HTTPS domain. Whatever you build is immediately live on the internet.
Create your first machine in under 5 seconds.
Automatic domains, configurable proxies.
SSH commands, proxy management, JSON output.
Branch an entire machine in seconds.
## What makes boxd different?
**Real VMs, not containers.** Each machine is a KVM microVM with its own Linux kernel, network stack, and persistent disk. Run systemd, Docker, install kernel modules -- no restrictions.
**Fork entire machines.** Copy a running machine -- full disk state, installed packages, running services -- into a new machine in seconds. Fork before risky changes, fork to test in parallel, destroy the fork when done.
**Instant HTTPS.** Every machine gets `name.boxd.sh` with TLS terminated at the proxy. Create additional subdomain proxies pointing to different ports. No certs, no DNS, no config.
**Built for agents.** Claude Code and Codex are pre-installed. The in-VM `boxd` CLI works without SSH keys. Every command outputs JSON. Agents can create, fork, and destroy machines autonomously.
**Sub-10ms suspend and resume.** Machines freeze in place and wake instantly when traffic arrives. Built on [Ignition](/primitives/suspend-resume), our open-source microVM engine. No cold starts, no wasted compute.
🇪🇺 **European sovereign infrastructure.** Hosted on EU hardware with no US cloud dependency. Your data stays in Europe.
## Use cases
**AI agent sandboxes.** Give each agent its own isolated machine with full root, persistent disk, and internet access. Agents manage their own VMs via the `boxd` CLI -- no SSH keys, JSON output, fully autonomous. Fork a known-good state before each task, destroy after. Unlike container-based sandboxes, agents get real hardware isolation with their own kernel.
**Autonomous coding agents.** Claude Code and Codex are pre-installed with a `boxd` skill that teaches agents the full platform. Agents can spin up machines, deploy apps, configure HTTPS proxies, fork for safe experimentation, and tear down -- all without human intervention.
**Development environments.** A full Ubuntu 24.04 machine with Docker, Go, Python, and your editor of choice. Unlike traditional CDEs that take minutes to start, boxd machines boot in milliseconds and persist across sessions. SSH in from anywhere, pick up where you left off.
**Live demos and prototypes.** Deploy an app and share the HTTPS link. No CI/CD pipeline, no hosting config. Your code is live the moment it listens on a port.
**Parallel testing.** Spin up multiple machines to test different configurations, library versions, or approaches simultaneously. Each is fully isolated with its own IP and HTTPS domain.
**Safe experimentation.** Fork your production-like environment, break things, learn, destroy the fork. The original is untouched. This is how agents should work -- cheap, disposable branches of entire computers.
## Every machine includes
* **Ubuntu 24.04** (unminimized, with man pages) -- Python 3, Go, Docker, build-essential
* **Claude Code and Codex** pre-installed with a built-in `boxd` skill and `CLAUDE.md`/`AGENTS.md` so agents understand the environment out of the box
* **HTTPS domain** at `name.boxd.sh` with configurable proxy routing
* **Public IPv4** -- direct SSH, SCP, VS Code Remote, port forwarding
* 🇪🇺 **European infrastructure** -- hosted on sovereign EU hardware, no US cloud dependency
* **2 vCPUs, 8 GB RAM, 100 GB disk** per machine (extendable on request)
# Domains
Source: https://docs.boxd.sh/primitives/domains
Every machine gets an HTTPS domain automatically.
## Automatic domains
Every machine gets a domain at `name.boxd.sh`. HTTPS traffic to that domain is forwarded to your machine (port 8000 by default, configurable via `proxy set-port`). TLS is terminated by the boxd proxy -- no certificate setup required.
```
https://myapp.boxd.sh -> your machine, port 8000 (default)
```
You can also create subdomain proxies (e.g., `api.myapp.boxd.sh`) pointing to different ports. See [HTTPS](/access/https) for details.
DNS records are created automatically when the machine boots. Records have a 60-second TTL.
## View your domains
```bash theme={"theme":"github-dark"}
ssh boxd.sh domain
```
```
name domain port
myapp myapp.boxd.sh 8000
test test.boxd.sh 8000
```
Filter by machine:
```bash theme={"theme":"github-dark"}
ssh boxd.sh domain --name=myapp
```
With `--json`:
```json theme={"theme":"github-dark"}
[
{
"name": "myapp",
"domain": "myapp.boxd.sh",
"port": 8000,
"url": "https://myapp.boxd.sh"
}
]
```
## Custom domains
Custom domain binding is not yet available. Contact the Azin team if you need a custom domain mapped to your machine.
# Fork
Source: https://docs.boxd.sh/primitives/fork
Copy a machine with its full disk state.
`fork` creates a new machine that is an exact copy of an existing one -- same filesystem, same installed packages, same data. The new machine gets its own name, IP, and HTTPS domain.
## Usage
```bash theme={"theme":"github-dark"}
ssh boxd.sh fork myapp
```
```
name: myapp-fork
id: 7a3f8c12-bb41-4e09-a5d2-91c3e4f0d678
ip: 5.135.42.19
forked from: myapp
boot: 1.8s
```
Specify a custom name:
```bash theme={"theme":"github-dark"}
ssh boxd.sh fork myapp --name=myapp-v2
```
With `--json`:
```json theme={"theme":"github-dark"}
{
"name": "myapp-fork",
"vm_id": "7a3f8c12-bb41-4e09-a5d2-91c3e4f0d678",
"ip": "5.135.42.19",
"image": "default",
"status": "running",
"boot_time_secs": 1.8,
"forked_from": "myapp"
}
```
The fork gets its own 100 GB disk, copied from the source machine. The fork is placed on the same worker as the source machine.
If the default name `{source}-fork` is already taken, the command fails. Use `--name` to pick a different name.
## Use cases
### Rollback
Fork before a risky change:
```bash theme={"theme":"github-dark"}
ssh boxd.sh fork myapp --name=myapp-backup
# make changes to myapp...
# something broke?
ssh boxd.sh destroy myapp
# myapp-backup still has the working state
```
### Experimentation
Try things without affecting your working machine:
```bash theme={"theme":"github-dark"}
ssh boxd.sh fork myapp --name=experiment
# break things freely
ssh boxd.sh destroy experiment
```
### Scaling
Need another instance of the same app:
```bash theme={"theme":"github-dark"}
ssh boxd.sh fork myapp --name=myapp-2
```
Both machines run the same code and data from the moment of the fork. Changes after the fork are independent.
# Machines
Source: https://docs.boxd.sh/primitives/machines
Create, list, and destroy machines.
A machine is a KVM microVM with its own kernel, network stack, persistent disk, public IP, and HTTPS domain.
## Create
```bash theme={"theme":"github-dark"}
ssh boxd.sh new --name=myapp
```
| Flag | Default | Description |
| ----------- | --------------- | ----------------------------------------------------------------------- |
| `--name` | auto-generated | Machine name. Must be unique across the cluster. Becomes the subdomain. |
| `--image` | cluster default | Container image for the root filesystem. |
| `--restart` | `always` | Restart policy: `always` or `never`. |
If you omit `--name`, boxd generates a random name like `blue-river`.
Output:
```
name: myapp
id: 9645b1e8-193d-4d11-86b1-f91deff5bbfb
ip: 5.135.42.17
boot: 1.8s
```
With `--json`:
```json theme={"theme":"github-dark"}
{
"name": "myapp",
"vm_id": "9645b1e8-193d-4d11-86b1-f91deff5bbfb",
"ip": "5.135.42.17",
"image": "default",
"status": "running",
"boot_time_secs": 1.8
}
```
## List
```bash theme={"theme":"github-dark"}
ssh boxd.sh list
```
```
name status ip image
myapp running 5.135.42.17 default
test running 5.135.42.18 default
```
Returns `no VMs` if you have none.
## Destroy
```bash theme={"theme":"github-dark"}
ssh boxd.sh destroy myapp
```
```
destroyed myapp
```
The name and IP are reserved -- recreating a machine with the same name reuses the same IP when possible.
## What's inside
The default image is Ubuntu 24.04 (unminimized, with man pages and full documentation):
**Languages and runtimes:**
* Python 3 with `uv` package manager and `pipx`
* Go (`golang-go`)
* `build-essential` (gcc, g++, make)
**Coding agents:**
* Claude Code (`claude`) -- Anthropic's CLI coding agent
* Codex (`codex`) -- OpenAI's CLI coding agent
Use them with a subscription (e.g., Claude Max) or by setting an API key inside your machine.
Each machine includes an `AGENTS.md` at `~/.config/boxd/AGENTS.md` that gives agents context about the boxd environment. It's symlinked to `~/.claude/CLAUDE.md` and `~/.codex/AGENTS.md` automatically.
**Containers:**
* Docker and Docker Compose
* Docker Buildx
**Editors:**
* vim, neovim
**Tools:**
* git, curl, wget, jq, ripgrep, sqlite3, rsync, tree, file, unzip
* GitHub CLI (`gh`)
**Monitoring:**
* btop, atop, iotop, ncdu
**Media:**
* ffmpeg, ImageMagick
**Network:**
* mitmproxy, socat, netcat
* Headless Chrome (via `headless-shell`)
**System:**
* nginx (configured on port 8000, disabled by default)
* systemd (full init system)
* openssh-server, openssh-client
Node.js is not pre-installed. Install it with `sudo apt install -y nodejs npm` or use a version manager like nvm.
The `boxd` user has passwordless sudo and is a member of the `docker` group.
# Suspend & resume
Source: https://docs.boxd.sh/primitives/suspend-resume
Freeze a machine and wake it in milliseconds.
Suspend and resume is **coming soon** to boxd. This page describes how it will work. The underlying technology is already built — boxd is based on [Ignition](https://github.com/lttle-cloud/ignition), an open-source microVM orchestrator by Azin that powers sub-10ms cold starts.
## The idea
Today, boxd machines run continuously. With suspend and resume, machines can be frozen in place — all memory, processes, and network state preserved — and woken up in under 10 milliseconds when traffic arrives.
This means you can have dozens of machines that cost nothing when idle and wake instantly when needed.
## How it works
Ignition uses a snapshot-based approach to eliminate initialization overhead:
1. **Run and snapshot.** Your machine boots, your app initializes, and Ignition captures the full VM state — memory, CPU registers, device state — into a snapshot.
2. **Suspend when idle.** When no traffic is flowing and no sessions are active, the machine suspends. The snapshot is retained in memory or on disk.
3. **Resume on demand.** When a request arrives at `name.boxd.sh`, the proxy detects the machine is suspended and triggers a restore. The VM resumes from the snapshot — no boot, no init, no application startup. It picks up exactly where it left off.
The restore happens in under 10 milliseconds. From the client's perspective, the machine was always running.
## Snapshot strategies
Ignition can capture the snapshot at different points:
* **After first listen** — snapshot once the app opens its first network socket (default)
* **After Nth listen** — wait for multiple sockets (e.g., app + database)
* **After specific port** — snapshot when a particular port is ready
* **After userspace ready** — snapshot once the kernel hands off to userspace
* **Manual** — your app signals when it's ready
The modified Linux kernel detects these triggers automatically. No code changes needed in your application.
## State retention
Snapshots can be retained in two ways:
* **In-memory** — fastest resume (\~1ms), uses RAM while suspended
* **On-disk** — slightly slower resume (\~5-10ms), no RAM cost while suspended
## What this enables
* **Pay for what you use.** Machines that serve occasional traffic suspend between requests.
* **Massive parallelism.** Spin up hundreds of machines, let them suspend when idle, wake on demand.
* **Instant APIs.** Deploy a service that cold-starts faster than a DNS lookup.
* **Agent workspaces.** An agent's VM suspends when the conversation ends and resumes instantly when the next one starts.
## Learn more
Ignition is open source. Read the code and architecture:
* [github.com/lttle-cloud/ignition](https://github.com/lttle-cloud/ignition)
* [DeepWiki: Ignition](https://deepwiki.com/lttle-cloud/ignition)
## Reference
Every command and its flags.
Quotas, CPU, memory, and disk.
# Quickstart
Source: https://docs.boxd.sh/quickstart
From zero to a live machine on the internet in under a minute.
If you are an agent reading this doc, visit [llms.txt](https://azin.mintlify.app/llms.txt), [llms-full.txt](https://azin.mintlify.app/llms-full.txt), or [skill.md](https://azin.mintlify.app/skill.md) instead.
```bash theme={"theme":"github-dark"}
ssh boxd.sh
```
If your key isn't linked yet, you'll see:
```
Your SSH key is not linked to a boxd account.
Open this URL to sign up or link your key:
https://boxd.sh/?session=95b750ef-...
Waiting...
```
Keep this terminal open. Open the URL in your browser and click **Sign in with GitHub to link key**. GitHub only requests public data -- no access to your repos or email.
Once authorized, your terminal confirms:
```
Linked! Welcome, gh-yourname.
Please reconnect.
```
To skip host key prompts, add this to `~/.ssh/config`:
```bash theme={"theme":"github-dark"}
Host boxd.sh
StrictHostKeyChecking no
UserKnownHostsFile /dev/null
```
```bash theme={"theme":"github-dark"}
ssh boxd.sh new --name=myapp
```
```
name: myapp
id: 9645b1e8-193d-4d11-86b1-f91deff5bbfb
ip: 5.135.42.17
boot: 1.8s
```
Your machine is running with a public IP and HTTPS domain.
nginx is pre-installed on port 8000 (the default proxy port). Start it:
```bash theme={"theme":"github-dark"}
ssh boxd.sh exec myapp -- sudo systemctl start nginx
```
Visit `https://myapp.boxd.sh` -- your machine is live on the internet.
## Adding more SSH keys
SSH from a different machine with a new key and go through the same link flow. The new key gets linked to your existing account (matched by GitHub identity).
## Start using your machine
Your machine is running. Now explore what you can do with it.
Run commands, manage proxies, JSON output.
Shell access, SCP, and port forwarding.
Automatic domains, configurable ports.
# CLI reference
Source: https://docs.boxd.sh/reference/cli
Every boxd command and its flags.
## SSH CLI (from outside)
All commands via SSH to `boxd.sh`. All accept `--json` for structured output.
```bash theme={"theme":"github-dark"}
ssh boxd.sh
```
Or interactively:
```bash theme={"theme":"github-dark"}
ssh boxd.sh
boxd>
```
### Machine management
| Command | Description |
| ------------------------------------------- | ----------------------------------- |
| `new [--name] [--image] [--restart=always]` | Create a machine |
| `list` | List your machines |
| `destroy ` | Permanently destroy a machine |
| `fork [--name]` | Copy a machine with full disk state |
#### new
Create a machine. Blocks until running (up to 30s timeout).
```bash theme={"theme":"github-dark"}
ssh boxd.sh new --name=myapp
```
| Flag | Default | Description |
| ----------- | --------------- | ---------------------------------------------------------- |
| `--name` | auto-generated | Machine name. Must be unique. Becomes the HTTPS subdomain. |
| `--image` | cluster default | Container image for the root filesystem. |
| `--restart` | `always` | Restart policy: `always` or `never`. |
Aliases: `list` can also be written as `ls`. `destroy` can also be written as `rm`.
#### destroy
Destroy a machine permanently. The name and IP are reserved for reuse.
```bash theme={"theme":"github-dark"}
ssh boxd.sh destroy myapp
```
Accepts a machine name or VM ID. Alias: `rm`.
#### fork
Copy a machine with its full disk state. See [Fork](/primitives/fork) for details.
```bash theme={"theme":"github-dark"}
ssh boxd.sh fork myapp --name=myapp-v2
```
| Flag | Default | Description |
| -------- | --------------- | ------------------------- |
| `--name` | `{source}-fork` | Name for the new machine. |
### Execution
| Command | Description |
| ---------------------------------- | --------------------------------- |
| `exec [--tty] -- ` | Run a command inside a machine |
| `connect ` | Open an interactive shell session |
#### exec
Run a command inside a machine. Commands execute as the `boxd` user with passwordless sudo.
```bash theme={"theme":"github-dark"}
ssh boxd.sh exec myapp -- uname -a
ssh boxd.sh exec myapp -- sudo systemctl start nginx
ssh boxd.sh exec myapp -- "cd /app && python3 server.py"
```
Add `--tty` for interactive commands:
```bash theme={"theme":"github-dark"}
ssh boxd.sh exec myapp --tty -- bash
```
#### connect
Open a full interactive shell session.
```bash theme={"theme":"github-dark"}
ssh boxd.sh connect myapp
```
Requires PTY support. Alias: `ssh`. For automation, use `exec` instead.
### Proxy management
| Command | Description |
| --------------------------------------------- | ------------------------------------ |
| `proxy list [--vm=NAME]` | List proxies (all if `--vm` omitted) |
| `proxy new --vm=NAME --port=PORT` | Create a subdomain proxy |
| `proxy delete --vm=NAME` | Remove a proxy |
| `proxy set-port [name] --vm=NAME --port=PORT` | Change proxy port |
#### proxy list
```bash theme={"theme":"github-dark"}
ssh boxd.sh proxy list --vm=myapp
ssh boxd.sh proxy list # all proxies
```
`--vm` is optional -- omit to list all proxies across all machines.
#### proxy new
Create a subdomain proxy. `api.myapp.boxd.sh` → port 3001:
```bash theme={"theme":"github-dark"}
ssh boxd.sh proxy new api --vm=myapp --port=3001
```
#### proxy delete
```bash theme={"theme":"github-dark"}
ssh boxd.sh proxy delete api --vm=myapp
```
Alias: `proxy rm`.
#### proxy set-port
Change the port for a proxy. Omit the name to change the default proxy.
```bash theme={"theme":"github-dark"}
ssh boxd.sh proxy set-port --vm=myapp --port=3000 # default proxy
ssh boxd.sh proxy set-port api --vm=myapp --port=3001 # named proxy
ssh boxd.sh proxy set-port --vm=myapp --port=auto # auto-detect
```
`auto` detects the port your app is listening on (default proxy only).
### Other
| Command | Description |
| ---------------------- | --------------------------- |
| `domain [--name=NAME]` | List HTTPS domains |
| `whoami` | Your user ID and SSH keys |
| `exit` / `quit` | Close the interactive shell |
### Global flags
| Flag | Description |
| -------- | ---------------------------------------- |
| `--json` | Output as JSON instead of formatted text |
***
## In-VM CLI
Every machine has the `boxd` command pre-installed. Auth is automatic by source IP -- no SSH keys needed. All commands accept `--json`.
```bash theme={"theme":"github-dark"}
boxd
```
### Commands
| Command | Description |
| ------------------------ | --------------------------------------- |
| `info` | Current VM name, status, image, proxies |
| `list` | List all your VMs |
| `new [--name] [--image]` | Create a VM |
| `fork [source] [--name]` | Fork a VM (defaults to current VM) |
| `destroy ` | Destroy a VM (cannot destroy self) |
| `exec -- ` | Run command in another VM |
| `connect ` | Interactive shell in another VM |
Aliases: `list`/`ls`, `destroy`/`rm`, `connect`/`ssh`.
### Proxy commands (in-VM)
Default to current VM when `--vm` is omitted.
| Command | Description |
| ------------------------------------------ | ---------------------- |
| `proxy list [--vm] [--all]` | List proxies |
| `proxy new --port=PORT [--vm]` | Create subdomain proxy |
| `proxy remove [--vm]` | Remove proxy |
| `proxy set-port [name] --port=PORT [--vm]` | Change proxy port |
```bash theme={"theme":"github-dark"}
boxd proxy set-port --port=3000 # change default port for this VM
boxd proxy new api --port=3001 # create api.name.boxd.sh
boxd proxy list # list proxies for this VM
boxd proxy rm api # remove (alias for remove)
```
# Resources and limits
Source: https://docs.boxd.sh/reference/resources
What each account gets.
## Per-machine resources
| Resource | Per machine |
| ------------------------ | ----------- |
| vCPUs | 2 |
| Memory | 8 GB |
| Disk | 100 GB |
| Max machines per account | 10 |
Every machine gets the same fixed resources. Need more? [Contact us](https://azin.run) to increase your quota.
## CPU
Each machine gets 2 CPU cores.
## Memory
Each machine gets 8 GB of RAM.
## Disk
Each machine gets a 100 GB disk. Disks use copy-on-write -- actual storage usage grows only as you write data.