CLI

The inis CLI is the fastest way to run sandboxes from a terminal or CI pipeline. It wraps the HTTP API — no SDK required.

Status: curl -fsSL https://inis.run/install.sh | bash

Install

curl -fsSL https://inis.run/install.sh | bash

The installer downloads a static binary for your OS/arch and adds it to your PATH. To pin a version:

curl -fsSL https://inis.run/install.sh | bash -s -- --version cli-v0.1.1

Configure

inis auth login

Or set INIS_API_KEY manually (CI, scripts). Optional override: INIS_BASE_URL=https://api.inis.run.

Commands

Command	Description
`inis run`	Stateless code execution (`--language`, `--file`)
`inis exec`	Run a shell command in a new or existing session
`inis ssh`	Open an interactive shell in a session
`inis sessions create`	Create a persistent session
`inis sessions get <id>`	Get session state
`inis sessions list`	List your sessions (`--state`, `--all` for history)
`inis sessions pause <id>`	Pause a session (snapshot, frees compute)
`inis sessions resume <id>`	Resume a paused session
`inis sessions destroy <id>`	Destroy a session
`inis sessions expose <id> --port N`	Expose a guest port → preview URL
`inis files read --session <id> <path>`	Read a file from a session
`inis files write --session <id> <path>`	Write a file to a session

inis ssh attaches a raw interactive shell to a session — like ssh or docker exec -it. It forwards your keyboard, streams output back, tracks window size, and exits with the remote shell's exit code.

inis ssh                 # create a fresh session, attach, destroy on exit
inis ssh --keep          # ...but keep it alive after you exit
inis ssh ses_abc         # attach to an existing session by id
inis ssh -c              # reattach to your most recent session
inis ssh --pick          # choose from your live and paused sessions

A paused session is resumed automatically before attaching, so a session you left days ago picks up where it was. --template and --size apply only when creating a session.

Detach vs. exit

There are two ways to leave a shell, and they mean different things:

Exit the shell (exit, or Ctrl-D at an empty prompt) ends the remote shell. For an ad-hoc inis ssh (no --keep) this destroys the session.
Detach with the ~. escape closes the connection but keeps the session running, so you can reattach later with inis ssh -c.

Escape sequences (recognised only at the start of a line):

Escape	Action
`~.`	Detach — keep the session running
`~~`	Send a literal `~`
`~?`	List the available escapes

Examples

# Stateless Python execution
inis run --language python -e 'print(sum(range(10)))'

# Run a script from disk
inis run --language python --file ./analyze.py

# Reuse a session across commands
SID=$(inis sessions create)
inis exec --session "$SID" -- pip install httpx -q
inis exec --session "$SID" -- python -c "import httpx; print(httpx.__version__)"
inis sessions destroy "$SID"

# Pause to free compute, resume later (or just attach — attach auto-resumes)
inis sessions pause "$SID"
inis sessions resume "$SID"

Session lifecycle

A session outlives any single connection. Detaching or disconnecting never destroys a session on its own — what happens next is governed by its on-detach policy, set at creation:

inis sessions create --on-detach pause     # default
inis sessions create --on-detach keep_live # stay hot for fast reattach
inis sessions create --on-detach destroy   # tear down on detach

Policy	On detach
`pause` (default)	Snapshot immediately — near-zero cost, warm resume
`keep_live`	Keep the VM running; auto-pause later on idle timeout
`destroy`	Tear the session down

History and retention

Destroyed sessions leave a lightweight history record so you can see what ran. List past sessions with --all or --state ended:

inis sessions list                 # live + paused
inis sessions list --all           # ...including ended sessions
inis sessions list --state ended   # just history

Each history row records when the session ended and why (end_reason): shell_exit, client_destroy, on_detach_destroy, max_lifetime, paused_ttl, or error.

Retention is configurable. A paused session is auto-destroyed once it sits past its paused-TTL, freeing its snapshot while the history metadata survives:

inis sessions create --paused-ttl-ms 86400000   # auto-destroy after 1 day paused

CI

Use INIS_API_KEY from your CI secret store. The binary is self-contained — no runtime dependencies.

- run: curl -fsSL https://inis.run/install.sh | bash
- run: inis run --language python -e "import sys; sys.exit(0)"
  env:
    INIS_API_KEY: ${{ secrets.INIS_API_KEY }}

CLI