> ## Documentation Index
> Fetch the complete documentation index at: https://docs.revyl.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Install the CLI
> Install the CLI that you and your coding agent use to run your app in cloud sessions, query Atlas, and run tests
**Give the CLI to your agent.** Point Cursor, Claude Code, Codex, or any coding agent at the Revyl CLI and it can create tests, upload builds, drive live devices, and run your suite end-to-end. Point it at your app and let it test.
The Revyl CLI puts Revyl in your terminal and your coding agent's: run your app in a cloud session, check what it does, query Atlas, and create and run tests. Local-first, git-friendly, and built for automation.
Prompt for your coding agent:
```text
Install the Revyl CLI on this machine.
Read https://docs.revyl.com/install.md and follow it. It's the current Revyl guide for this, so prefer it over anything you remember about Revyl.
Use the install script, `curl -fsSL https://revyl.com/install.sh | sh`, then run `export PATH=$HOME/.revyl/bin:$PATH` in your shell. Run `revyl auth login` in the background or a second terminal and give me the approval link it prints while it waits, so I can approve it in my browser within 10 minutes.
You're done when `revyl version` prints a version and `revyl auth status` shows the CLI is signed in.
Ask me before anything that needs my login or approval.
```
## Why Use the CLI?
- **Local-first workflow** - Edit tests in your IDE, sync with the cloud
- **CI/CD ready** - Integrate testing into your build pipelines
- **Fast iteration** - Run tests directly from your terminal
- **Version control** - Store test definitions alongside your code
## Installation
Install the CLI using your preferred method:
```bash Shell (macOS/Linux)
curl -fsSL https://revyl.com/install.sh | sh
```
```powershell Windows
irm https://raw.githubusercontent.com/RevylAI/revyl-cli/main/scripts/install.ps1 | iex
```
```bash Homebrew (macOS)
brew install RevylAI/tap/revyl
```
```bash pipx (cross-platform)
pipx install revyl
```
```bash uv
uv tool install revyl
```
```bash pip
pip install revyl
```
* Homebrew remains a good macOS package-manager option when you want updates through `brew upgrade revyl`.
* The PyPI package is CLI-only and includes the native Revyl binary for the
selected platform. It does not download a binary when `revyl` first runs.
* The shell installer downloads the native binary directly. Package-manager
installs via pip, pipx, or uv download the platform wheel at install time.
Running in a restricted build runner, container, or coding-agent sandbox? See
[Sandboxed Environments](/agents/sandboxed-environments) for writable-state,
non-interactive `PATH`, proxy and certificate trust, least-privilege egress,
and the boundary between local checks and authorized cloud actions.
### Direct download
Download the binary for your platform from [GitHub Releases](https://github.com/RevylAI/revyl-cli/releases). Available builds:
| Platform | Architecture | Asset |
|----------|--------------|-------|
| macOS | arm64 (Apple Silicon) | `revyl-darwin-arm64` |
| macOS | amd64 (Intel) | `revyl-darwin-amd64` |
| Linux | arm64 | `revyl-linux-arm64` |
| Linux | amd64 | `revyl-linux-amd64` |
| Windows | amd64 | `revyl-windows-amd64.exe` |
| Windows | arm64 | `revyl-windows-arm64.exe` |
After downloading, make the binary executable (macOS/Linux) and place it on your `PATH`.
### Verify Installation
```bash
revyl version
```
You should see output like:
```
revyl version 0.1.x
```
### Run Diagnostics
Check that everything is configured correctly:
```bash
revyl doctor
```
This command verifies:
- CLI version and updates
- Authentication status
- API connectivity
- Project configuration
- Build system detection
## Updating the CLI
Use the upgrade command that matches how you installed:
```bash Shell installer
curl -fsSL https://revyl.com/install.sh | sh
```
```bash Homebrew
brew upgrade revyl
```
```bash pipx
pipx upgrade revyl
```
```bash uv
uv tool upgrade revyl
```
```bash pip
pip install --upgrade revyl
```
```bash Direct download
revyl upgrade
```
After a command succeeds or fails, Revyl can show an update notice. In an interactive terminal, direct-download and Homebrew installations offer **Update now? [Y/n]**. Accepting installs the update and verifies the installed version without rerunning your command, changing its exit status, migrating project configuration, or refreshing agent skills. Release checks read the latest-release redirect on github.com rather than the rate-limited GitHub API, are cached for 24 hours (including failed checks), and never fail the command. Non-interactive runs never wait for a check; an interactive terminal waits at most two seconds for a pending one.
CI, detected coding agents, `--json` and `--quiet` runs, and piped or redirected commands never receive the interactive prompt. They get one stderr line at most once every 24 hours per machine, such as `Revyl CLI 0.1.131 is available (current 0.1.96). Upgrade with: brew upgrade revyl`. The command matches the installation: Homebrew, pip, pipx, uv, and npm show their package-manager command, and the shell installer, direct downloads, and unrecognized locations show `revyl upgrade`. The notice never writes to stdout, so `--json` output is unchanged. Before the Revyl API stops accepting an older CLI version, it announces the minimum version it will require, and a CLI below that minimum prints a stronger stderr warning once every 24 hours per machine in every output mode, naming the same upgrade command. MCP, version, completion, and upgrade commands never show a notice. Set `REVYL_NO_UPDATE_NOTIFIER=1` to disable update checks and notices, for example when a script parses stdout and stderr together.
If you installed via direct download, `revyl upgrade` performs a self-update (downloads the latest binary, verifies checksums, and replaces the executable). To check for updates without installing, use:
```bash
revyl upgrade --check
```
CLI upgrades leave installed agent skills unchanged. After updating the binary,
inspect your installed skills and update them separately:
```bash
revyl skill list --installed --json
revyl skill update
revyl skill update --global
```
`skill update` refreshes only already-installed, unmodified Revyl-managed
packages from the current CLI. It preserves local edits and unmanaged packages,
reports conflicts, and never installs additional skills. The default update
scope is the current project; `--global` selects your home directory.
No update path, including Homebrew, npm, pip, and the install script, changes
installed skills, so there is nothing to turn off. A package you edited or
combined with other skills is reported as `preserved`, and `skill update` exits
non-zero; name only the skills you want refreshed, such as
`revyl skill update revyl-cli-dev-loop`, to update around it. Do not use
`skill install --force` on customized skills: it replaces them. Set
`REVYL_NO_POST_UPGRADE_SKILL_INSTALL=1` to hide the post-upgrade reminder. On
CLI v0.1.109 and earlier, the same variable skips the skill refresh that
`revyl upgrade` ran after updating.
## Global Flags
These flags work with any command:
| Flag | Description |
|------|-------------|
| `-C, --chdir ` | Run as if started in this directory (the project dir containing `.revyl/`) |
| `--debug` | Enable debug logging |
| `--json` | Output results as JSON |
| `--quiet, -q` | Suppress non-essential output |
## Pick Your Path
| I want to... | Start here |
|---|---|
| Test an **Expo** app | [Expo Build Guide](/frameworks/expo) |
| Test a **React Native** (bare) app | [React Native Build Guide](/frameworks/react-native) |
| Test a **Flutter** app | [Flutter Build Guide](/frameworks/flutter) |
| Test a native **iOS (Swift)** app | [iOS Build Guide](/frameworks/ios) |
| Test a native **Android (Kotlin/Java)** app | [Android Build Guide](/frameworks/android) |
| **Control a cloud device** (no app build) | [Device Quickstart](/devices) |
| **Build or refresh an Atlas map** | [Explore from the CLI](/atlas/explore-cli) |
| Set up **CI/CD** testing | [CI/CD Integration](/tests/ci) |
| Install **AI agent skills** | [Agent Skills](/agents/skills) |
| Connect my **AI coding agent over MCP** | [MCP Setup](/agents/mcp) |
Each build guide walks you through the exact 2-3 commands to go from your repo to a passing test.
## What Happens Next
After picking your framework above, your typical workflow is:
1. **Dev loop** -- `revyl dev` connects a cloud device to your local code with hot reload
2. **Create tests** -- write YAML test definitions and run them
3. **CI/CD** -- run tests on every PR
## What You Can Do
Every surface of Revyl is available from the terminal.
- **Tests**: create, sync, edit, and run tests from YAML files stored alongside your code
- **Builds**: upload iOS and Android binaries, organize them into branches, pin a branch to a build, sync with CI builds
- **Devices**: spin up cloud iOS and Android sessions, drive them with tap/swipe/type, set GPS, open deep links
- **Explore**: discover app surfaces and build or refresh an Atlas map
- **Dev Loop**: iterate on tests with hot reload against a live device
- **Workflows**: trigger test suites, watch runs, pull results
- **Reports**: download video, logs, and network traces
- **Library**: manage modules, global variables, launch configuration, scripts, and files
See the full [command reference](/reference/cli).
## Built for Agents
The CLI is designed to be delegated to an AI agent. Give your agent access to the CLI and it can run your app, check its own changes in a live session, and read Atlas.
**What agents can do with Revyl:**
- Bootstrap a new test suite from scratch by exploring your app on a live device
- Debug failing tests by reading reports, reproducing on a device, and fixing the steps
- Write tests that match feature PRs and add them to your workflow
- Upload builds, pin branches, and trigger regression suites
- Scrape device logs and network traces to root-cause flakes
## Key Resources
Set up your API key
Connect Revyl to Cursor, Claude Code, or Codex
Every CLI command and flag
Project setup and configuration
Run tests from your pipelines
Build an Atlas map from the terminal
Hot reload with live devices
Source, releases, and README