> ## 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.

# Installation

> The power tool for you and your agents

<Note>
  **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.
</Note>

The Revyl CLI brings AI-powered mobile testing to your terminal. Create, sync, and run tests locally without leaving your development environment. Local-first, git-friendly, and built for automation.

## 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:

<CodeGroup>
  ```bash Shell (macOS/Linux) theme={null}
  curl -fsSL https://revyl.com/install.sh | sh
  ```

  ```powershell Windows theme={null}
  irm https://raw.githubusercontent.com/RevylAI/revyl-cli/main/scripts/install.ps1 | iex
  ```

  ```bash Homebrew (macOS) theme={null}
  brew install RevylAI/tap/revyl
  ```

  ```bash pipx (cross-platform) theme={null}
  pipx install revyl
  ```

  ```bash uv theme={null}
  uv tool install revyl
  ```

  ```bash pip theme={null}
  pip install revyl
  ```
</CodeGroup>

* 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 auto-download the CLI binary on first use.

### Direct download <a id="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` |

After downloading, make the binary executable (macOS/Linux) and place it on your `PATH`.

### Verify Installation

```bash theme={null}
revyl version
```

You should see output like:

```
revyl version 1.x.x
```

### Run Diagnostics

Check that everything is configured correctly:

```bash theme={null}
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:

<CodeGroup>
  ```bash Shell installer theme={null}
  curl -fsSL https://revyl.com/install.sh | sh
  ```

  ```bash Homebrew theme={null}
  brew upgrade revyl
  ```

  ```bash pipx theme={null}
  pipx upgrade revyl
  ```

  ```bash pip theme={null}
  pip install --upgrade revyl
  ```

  ```bash Direct download theme={null}
  revyl upgrade
  ```
</CodeGroup>

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 theme={null}
revyl upgrade --check
```

When `revyl upgrade` performs a Homebrew or direct-download upgrade, it also refreshes existing Cursor, Codex, and Claude Code skill directories with the new embedded Revyl skills. If you update Revyl with a package manager command directly, refresh manually with:

```bash theme={null}
revyl skill install --force
```

## Global Flags

These flags work with any command:

| Flag          | Description                   |
| ------------- | ----------------------------- |
| `--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](/builds/frameworks/expo)                 |
| Test a **React Native** (bare) app          | [React Native Build Guide](/builds/frameworks/react-native) |
| Test a **Flutter** app                      | [Flutter Build Guide](/builds/frameworks/flutter)           |
| Test a native **iOS (Swift)** app           | [iOS Build Guide](/builds/frameworks/xcode)                 |
| Test a native **Android (Kotlin/Java)** app | [Android Build Guide](/builds/frameworks/gradle)            |
| **Control a cloud device** (no app build)   | [Device Quickstart](/cli/device/quickstart)                 |
| Set up **CI/CD** testing                    | [CI/CD Integration](/guides/run-tests-ci-cd)                |
| Install **AI agent skills**                 | [Agent Skills](/integrations/skills)                        |
| Connect my **AI coding agent over MCP**     | [MCP Setup](/integrations/mcp-setup)                        |

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, pin versions, sync with CI builds
* **Devices**: spin up cloud iOS and Android sessions, drive them with tap/swipe/type, set GPS, open deep links
* **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 vars, scripts, and files

See the full [command reference](/cli/command-reference).

## Built for Agents

The CLI is designed to be delegated to an AI agent. Give your agent access to the CLI and it gains full control of your mobile testing stack.

**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 versions, and trigger regression suites
* Scrape device logs and network traces to root-cause flakes

## Key Resources

<CardGroup cols={2}>
  <Card title="Authentication" icon="key" href="/cli/authentication">
    Set up your API key
  </Card>

  <Card title="MCP Setup" icon="plug" href="/cli/mcp-setup">
    Connect Revyl to Cursor, Claude Code, or Codex
  </Card>

  <Card title="Command Reference" icon="book" href="/cli/command-reference">
    Every CLI command and flag
  </Card>

  <Card title="Configuration" icon="cog" href="/cli/configuration">
    Project setup and configuration
  </Card>

  <Card title="CI/CD" icon="code-branch" href="/guides/run-tests-ci-cd">
    Run tests from your pipelines
  </Card>

  <Card title="Dev Loop" icon="bolt" href="/develop/dev-loop-overview">
    Hot reload with live devices
  </Card>

  <Card title="GitHub Repository" icon="github" href="https://github.com/RevylAI/revyl-cli">
    Source, releases, and README
  </Card>
</CardGroup>