This page is auto-generated from the live Revyl CLI schema (revyl schema --format markdown). Version: 0.1.13 Proactive reliability for mobile apps. Catch bugs before your users do.

Global Flags

Flag	Type	Default	Description
`--debug`	bool	false	Enable debug logging
`--dev`	bool	false	Use local development servers (reads PORT from .env files)
`--json`	bool	false	Output results as JSON (where supported)
`-q, --quiet`	bool	false	Suppress non-essential output

Commands

`app`

Manage apps Manage apps for your organization. An app is a named container that stores versions of your app binary. Tests reference an app to know which binary to install on the device. Commands: create - Create a new app list - List all apps delete - Delete an app Usage: revyl app

`app create`

Create a new app Create a new app in your organization. An app stores uploaded app builds so tests can reference them. Examples: revyl app create —name “My App” —platform android revyl app create —name “iOS Dev Client” —platform ios revyl app create —name “My App” —platform android —json Usage: revyl app create [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output result as JSON
`--name`	string		Name for the app (required)
`--platform`	string		Target platform: ios or android (required)

`app delete`

Delete an app Delete an app and all its build versions. Examples: revyl app delete “My App iOS” # Delete by name revyl app delete <uuid> # Delete by ID revyl app delete “My App iOS” —force # Skip confirmation Usage: revyl app delete <name|id> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`app list`

List all apps List all apps in your organization. Examples: revyl app list # List all apps revyl app list —platform android # Filter by platform revyl app list —json # JSON output Usage: revyl app list [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--platform`	string		Filter by platform (android, ios)

`auth`

Manage authentication Manage authentication with Revyl. COMMANDS: login - Authenticate with Revyl (opens browser by default) logout - Remove stored credentials status - Show current authentication status AUTHENTICATION METHODS: Browser (default): Opens your browser to sign in with your Revyl account API Key (—api-key): Manual API key entry for CI/CD or headless environments CREDENTIALS: Credentials are stored in ~/.revyl/credentials.json Usage: revyl auth

`auth billing`

Manage billing and payment method Open the Revyl billing page in your browser. Add a payment method to unlock 30 free simulator minutes per platform per month. EXAMPLES: revyl auth billing # Open billing page revyl auth billing —dev # Open local dev billing page Usage: revyl auth billing Authenticate with Revyl Authenticate with Revyl. By default, opens your browser to sign in with your Revyl account. Use —api-key flag for manual API key entry (useful for CI/CD). BROWSER AUTHENTICATION (default):

Opens your browser to the Revyl login page
Sign in with your email/password or SSO
Authorize the CLI to access your account
Credentials are automatically saved

API KEY AUTHENTICATION (—api-key):

Get your API key from https://app.revyl.ai/settings/api-keys
Enter the API key when prompted
Credentials are saved to ~/.revyl/credentials.json

EXAMPLES: revyl auth login # Browser-based login (recommended) revyl auth login —api-key # Manual API key entry revyl auth status # Check authentication status Usage: revyl auth login [flags] Flags:

Flag	Type	Default	Description
`--api-key`	bool	false	Use API key authentication instead of browser

`auth logout`

Remove stored credentials Remove stored credentials from ~/.revyl/credentials.json Usage: revyl auth logout

`auth status`

Show authentication status Show current authentication status and user information. Usage: revyl auth status

`build`

Manage app builds Manage app builds for testing. Commands: upload - Build and upload the app list - List uploaded build versions delete - Delete an app or specific build version Usage: revyl build

`build delete`

Delete an app or build version Delete an app (and all build versions) or a specific build version. Use —version to delete only a specific build version. Examples: revyl build delete “My App iOS” # Delete entire app revyl build delete “My App iOS” —version v1.2.3 # Delete specific build version only revyl build delete “My App iOS” —force # Skip confirmation Usage: revyl build delete <name|id> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt
`--version`	string		Delete specific build version only

`build list`

List uploaded build versions List all uploaded build versions. If an app is configured locally, lists builds for that app. Otherwise, shows all apps in your organization. Examples: revyl build list # List builds (or show org apps) revyl build list —app <id> # List builds for specific app revyl build list —platform android # Filter org apps by platform Usage: revyl build list [flags] Flags:

Flag	Type	Default	Description
`--app`	string		App ID to list builds for
`--branch`	string		Filter builds by git branch (use HEAD for current branch)
`--json`	bool	false	Output results as JSON
`--platform`	string		Filter by platform (android, ios) when listing org apps

`build upload`

Build and upload the app Build the app and upload it to Revyl. By default, builds both iOS and Android concurrently if both platforms are configured. Use —platform to build only one platform. This command will:

Run the build command(s) from .revyl/config.yaml
Upload the resulting artifact(s) to Revyl
Track metadata (git commit, branch, machine, etc.)

Examples: revyl build upload # Build both iOS and Android concurrently revyl build upload —platform ios # Build iOS only revyl build upload —platform android # Build Android only revyl build upload —skip-build # Upload existing artifacts revyl build upload —app <id> # Upload to specific app revyl build upload —name “My App” # Create app with specified name revyl build upload —name “My App” -y # Create and auto-save to config Usage: revyl build upload [flags] Flags:

Flag	Type	Default	Description
`--app`	string		App ID to upload to
`--dry-run`	bool	false	Show what would be uploaded without uploading
`--json`	bool	false	Output results as JSON
`--name`	string		Name for new app (used when creating)
`--platform`	string		Platform to build for (ios, android)
`--scheme`	string		Xcode scheme to use for iOS builds (overrides config)
`--set-current`	bool	false	Set this version as the current version
`--skip-build`	bool	false	Skip build step, upload existing artifact
`--version`	string		Version string for the upload (default: auto-generated)
`-y, --yes`	bool	false	Automatically confirm prompts (e.g., save to config)

`config`

View and edit project settings View and edit local project settings in .revyl/config.yaml. EXAMPLES: revyl config path revyl config show revyl config set open-browser false revyl config set timeout 900 Usage: revyl config

`config edit`

Open config in your editor Usage: revyl config edit

`config path`

Show project config path Usage: revyl config path

`config set`

Set a project setting Set a project setting. Supported keys: open-browser true|false timeout positive integer seconds hotreload.provider expo|react-native|swift|android hotreload.app-scheme URL scheme (e.g. myapp) hotreload.port dev server port (e.g. 8081) hotreload.use-exp-prefix true|false Usage: revyl config set <key> <value>

`config show`

Show project settings Usage: revyl config show

`dev`

Local development loop with live device Start and manage the iterative local development loop. Auto-detects your project type (Expo, React Native, Swift, Android), starts hot reload, provisions a cloud device, installs the latest dev build, and opens a live viewer. On first run, auto-configures dev mode if not already set up. Usage: revyl dev [flags] Flags:

Flag	Type	Default	Description
`--app-id`	string		App ID to resolve latest build from
`--build`	bool	false	Force build+upload before starting
`--build-version-id`	string		Specific build version ID to use
`--no-open`	bool	false	Do not open the live device viewer in browser
`--open`	bool	true	Open live device viewer in browser
`--platform`	string	ios	Device platform to start (ios or android)
`--platform-key`	string		Explicit build.platforms key for the dev client build
`--port`	int	8081	Port for local dev server
`--timeout`	int	300	Device idle timeout in seconds

`dev start`

Start a hot reload device loop Usage: revyl dev start [flags] Flags:

Flag	Type	Default	Description
`--app-id`	string		App ID to resolve latest build from
`--build`	bool	false	Force build+upload before starting
`--build-version-id`	string		Specific build version ID to use
`--no-open`	bool	false	Do not open the live device viewer in browser
`--open`	bool	true	Open live device viewer in browser
`--platform`	string	ios	Device platform to start (ios or android)
`--platform-key`	string		Explicit build.platforms key for the dev client build
`--port`	int	8081	Port for local dev server
`--timeout`	int	300	Device idle timeout in seconds

`dev test`

Run test commands with hot reload defaults Usage: revyl dev test

`dev test create`

Create a test with hot reload defaults Usage: revyl dev test create <name> [flags] Flags:

Flag	Type	Default	Description
`--app`	string		App ID to associate with the test
`--dry-run`	bool	false	Show what would be created without creating
`--force`	bool	false	Update existing test if name already exists
`--from-file`	string		Create test from YAML file (copies to .revyl/tests/ and pushes)
`--interactive`	bool	false	Create test interactively with real-time device feedback
`--module`	stringSlice	[]	Module name or ID to insert as module_import block (can be repeated)
`--no-open`	bool	false	Skip opening browser to test editor
`--platform`	string	ios	Target platform (android, ios)
`--platform-key`	string		Build platform key for hot reload dev client
`--port`	int	8081	Port for dev server
`--tag`	stringSlice	[]	Tag to assign after creation (can be repeated)

`dev test open`

Open a test with hot reload defaults Usage: revyl dev test open <name> [flags] Flags:

Flag	Type	Default	Description
`--interactive`	bool	false	Edit test interactively with real-time device feedback
`--no-open`	bool	false	Skip opening browser (with —interactive: output URL and wait for Ctrl+C)
`--platform-key`	string		Build platform key for hot reload dev client
`--port`	int	8081	Port for dev server

`dev test run`

Run a test in dev mode (hot reload) Usage: revyl dev test run <name|id> [flags] Flags:

Flag	Type	Default	Description
`-b, --build-id`	string		Specific build version ID
`--github-actions`	bool	false	Format output for GitHub Actions
`--json`	bool	false	Output results as JSON
`--location`	string		Initial GPS location as lat,lng (e.g. 37.7749,-122.4194)
`--no-wait`	bool	false	Exit after test starts without waiting
`--open`	bool	false	Open report in browser when complete
`--platform`	string	ios	Device platform to use (ios or android)
`--platform-key`	string		Explicit build.platforms key for dev client build
`--port`	int	8081	Port for dev server
`-r, --retries`	int	1	Number of retry attempts (1-5)
`-t, --timeout`	int	3600	Timeout in seconds
`-v, --verbose`	bool	false	Show detailed monitoring output

`device`

Direct device interaction (start, tap, type, screenshot, etc.) Provision cloud-hosted Android/iOS devices and interact with them directly. Examples: revyl device start —platform android —open revyl device tap —target “Sign In” revyl device instruction “log in with [email protected] and verify the dashboard loads” Usage: revyl device

`device back`

Press Android back button Usage: revyl device back [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device clear-text`

Clear text in an element (—target or —x/—y) Usage: revyl device clear-text [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--target`	string		Element description (grounded)
`--x`	int	0	X coordinate (raw)
`--y`	int	0	Y coordinate (raw)

`device code-execution`

Run one code_execution step on the active device Run a code execution step on the active device session. Three modes:

By script ID: revyl device code-execution <script-id>
From local file: revyl device code-execution —file ./script.py —runtime python
Inline code: revyl device code-execution —code “print(‘hello’)” —runtime python

Modes 2 and 3 create an ephemeral script on the backend, execute it, then clean up. Usage: revyl device code-execution [script-id] [flags] Flags:

Flag	Type	Default	Description
`--code`	string		Run inline code string (creates ephemeral script)
`--file`	string		Run code from a local file (creates ephemeral script)
`--json`	bool	false	Output as JSON
`--runtime`	string		Script runtime for —file/—code (python, javascript, typescript, bash)
`-s, --s`	int	-1	Session index to target (-1 for active)

`device doctor`

Run diagnostics on auth, session, worker, and grounding health Usage: revyl device doctor [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device double-tap`

Double-tap an element (—target or —x/—y) Usage: revyl device double-tap [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--target`	string		Element description (grounded)
`--x`	int	0	X coordinate (raw)
`--y`	int	0	Y coordinate (raw)

`device download-file`

Download a file to device from URL Usage: revyl device download-file [flags] Flags:

Flag	Type	Default	Description
`--filename`	string		Optional destination filename on the device
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--url`	string		URL to download from (required)

`device drag`

Drag from one point to another (—start-x/—start-y/—end-x/—end-y) Usage: revyl device drag [flags] Flags:

Flag	Type	Default	Description
`--end-x`	int	0	Ending X coordinate
`--end-y`	int	0	Ending Y coordinate
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--start-x`	int	0	Starting X coordinate
`--start-y`	int	0	Starting Y coordinate

`device extract`

Run one extract step on the active device Usage: revyl device extract <description> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--variable-name`	string		Optional variable name to store extracted data under

`device history`

Show device session history Show recent device session history from the server. Usage: revyl device history [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`--limit`	int	20	Maximum number of sessions to show

`device home`

Go to device home screen Usage: revyl device home [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device info`

Show session info (-s <index> for specific session) Usage: revyl device info [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device install`

Install an app from a URL or build version ID Usage: revyl device install [flags] Flags:

Flag	Type	Default	Description
`--app-url`	string		URL to download app from (.apk or .ipa)
`--build-version-id`	string		Build version ID from a previous upload; download URL is resolved automatically
`--bundle-id`	string		Bundle ID (optional, auto-detected)
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device instruction`

Run one instruction step on the active device Usage: revyl device instruction <description> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device key`

Send a non-printable key (ENTER or BACKSPACE) Usage: revyl device key [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`--key`	string		Key to send (ENTER or BACKSPACE)
`-s, --s`	int	-1	Session index to target (-1 for active)

`device kill-app`

Kill the installed app Usage: revyl device kill-app [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device launch`

Launch an installed app by bundle ID Usage: revyl device launch [flags] Flags:

Flag	Type	Default	Description
`--bundle-id`	string		App bundle ID to launch (required)
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device list`

List all active device sessions Usage: revyl device list [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON

`device long-press`

Long press an element (—target or —x/—y, —duration) Usage: revyl device long-press [flags] Flags:

Flag	Type	Default	Description
`--duration`	int	1500	Press duration in ms
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--target`	string		Element description (grounded)
`--x`	int	0	X coordinate (raw)
`--y`	int	0	Y coordinate (raw)

`device navigate`

Open a URL or deep link on device Usage: revyl device navigate [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--url`	string		URL or deep link to open (required)

`device open-app`

Open a system app by name (e.g. settings, safari, chrome) Usage: revyl device open-app [flags] Flags:

Flag	Type	Default	Description
`--app`	string		App name (e.g. settings, safari) or raw bundle ID (required)
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device pinch`

Pinch/zoom an element (—target or —x/—y, plus —scale) Usage: revyl device pinch [flags] Flags:

Flag	Type	Default	Description
`--duration`	int	300	Pinch duration in ms
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--scale`	float64	2	Zoom scale (`>1` zoom in, `<1` zoom out)
`--target`	string		Element description (grounded)
`--x`	int	0	X coordinate (raw)
`--y`	int	0	Y coordinate (raw)

`device report`

View the report for the active device session Usage: revyl device report [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device screenshot`

Capture device screenshot Usage: revyl device screenshot [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`--out`	string		Output file path
`-s, --s`	int	-1	Session index to target (-1 for active)

`device set-location`

Set device GPS location Usage: revyl device set-location [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`--lat`	float64	0	Latitude (-90 to 90, required)
`--lon`	float64	0	Longitude (-180 to 180, required)
`-s, --s`	int	-1	Session index to target (-1 for active)

`device shake`

Trigger shake gesture Usage: revyl device shake [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device start`

Start a device session Usage: revyl device start [flags] Flags:

Flag	Type	Default	Description
`--app-id`	string		App ID to resolve latest build from
`--app-link`	string		Deep link to launch after app start
`--app-url`	string		Direct app artifact URL (.apk/.ipa/.zip)
`--build-version-id`	string		Build version ID to install
`--device`	bool	false	Interactively select device model and OS version
`--device-model`	string		Target device model (e.g. “iPhone 16”)
`--json`	bool	false	Output as JSON
`--open`	bool	false	Open viewer in browser after device is ready
`--os-version`	string		Target OS version (e.g. “iOS 18.5”)
`--platform`	string	ios	Platform: ios or android
`--timeout`	int	300	Idle timeout in seconds

`device stop`

Stop a device session (-s <index> or —all) Usage: revyl device stop [flags] Flags:

Flag	Type	Default	Description
`--all`	bool	false	Stop all sessions
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device swipe`

Swipe (—target or —x/—y, plus —direction) Usage: revyl device swipe [flags] Flags:

Flag	Type	Default	Description
`--direction`	string		Direction: up, down, left, right (required)
`--duration`	int	500	Swipe duration in ms
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--target`	string		Element description (grounded)
`--x`	int	0	X coordinate (raw)
`--y`	int	0	Y coordinate (raw)

`device tap`

Tap an element (—target or —x/—y) Usage: revyl device tap [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--target`	string		Element description (grounded)
`--x`	int	0	X coordinate (raw)
`--y`	int	0	Y coordinate (raw)

`device targets`

List available device models and OS versions List available device models and OS versions for each platform. Usage: revyl device targets [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`--platform`	string		Filter to a specific platform (ios or android)

`device type`

Type text (—target or —x/—y, plus —text) Usage: revyl device type [flags] Flags:

Flag	Type	Default	Description
`--clear-first`	bool	true	Clear field before typing
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)
`--target`	string		Element description (grounded)
`--text`	string		Text to type (required)
`--x`	int	0	X coordinate (raw)
`--y`	int	0	Y coordinate (raw)

`device use`

Switch active session to the given index Usage: revyl device use <index>

`device validation`

Run one validation step on the active device Usage: revyl device validation <description> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`device wait`

Wait for a fixed duration on the device session Usage: revyl device wait [flags] Flags:

Flag	Type	Default	Description
`--duration-ms`	int	1000	Wait duration in milliseconds
`--json`	bool	false	Output as JSON
`-s, --s`	int	-1	Session index to target (-1 for active)

`docs`

Open Revyl documentation in browser Usage: revyl docs

`doctor`

Check CLI health and connectivity Run diagnostic checks on the Revyl CLI installation. CHECKS PERFORMED:

CLI version (current vs latest available)
Authentication status (valid API key?)
API connectivity (can reach backend.revyl.ai?)
Project configuration (.revyl/config.yaml exists and valid?)
Build system detection (if in project directory)

OUTPUT: Human-readable by default, JSON with —json flag. EXAMPLES: revyl doctor # Run all checks revyl doctor —json # Output as JSON for scripting Usage: revyl doctor [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON

`init`

Initialize Revyl project configuration Initialize a Revyl project in the current directory via a guided wizard. The wizard walks you through:

Project setup — detect build system, create config
Authentication — check or prompt browser login
Create apps — for each detected platform, create or select an app
Hot reload setup — configure Expo hot reload defaults
First build — build and upload your artifact
Create first test — create a test on the platform

Use —non-interactive / -y to skip the wizard and just create config. Examples: revyl init # Full guided wizard revyl init -y # Non-interactive: detect + create config only revyl init —provider expo # Force Expo as hot reload provider revyl init —project ID # Link to existing Revyl project revyl init —detect # Re-run build system detection revyl init —force # Overwrite existing configuration Usage: revyl init [flags] Flags:

Flag	Type	Default	Description
`--detect`	bool	false	Re-run build system detection
`--force`	bool	false	Overwrite existing configuration
`--hotreload-app-scheme`	string		Override Expo hotreload.providers.expo.app_scheme
`-y, --non-interactive`	bool	false	Skip wizard prompts, just create config
`--project`	string		Link to existing Revyl project ID
`--provider`	string		Force dev mode provider (expo, react-native, swift, android)
`--xcode-scheme`	stringSlice	[]	Override Xcode scheme by build platform key (format: key=Scheme, repeatable)

`mcp`

MCP server commands MCP (Model Context Protocol) server commands. The MCP server allows AI agents to interact with Revyl through the Model Context Protocol, enabling automated test execution and management via AI assistants like Claude or Cursor. Commands: serve - Start the MCP server over stdio Usage: revyl mcp

`mcp serve`

Start MCP server over stdio Start the Revyl MCP server over stdio. This command starts an MCP server that communicates via JSON-RPC over stdin/stdout. It’s designed to be launched by AI hosts like Cursor or Claude Desktop. The server exposes the following tools: Test execution:

run_test: Run a test by name or ID (supports —location override)
run_workflow: Run a workflow by name or ID (supports app and location overrides)
get_test_status: Get status of a running test
cancel_test: Cancel a running test execution
cancel_workflow: Cancel a running workflow execution

Test management:

list_tests: List available tests from .revyl/config.yaml
list_remote_tests: List all tests in the organization from the API
create_test: Create a runnable test from YAML content and/or module refs
update_test: Push updated YAML content to an existing test
delete_test: Delete a test by name or UUID
validate_yaml: Validate YAML test syntax without creating

Workflow management:

list_workflows: List all workflows in the organization
create_workflow: Create a new workflow
delete_workflow: Delete a workflow
open_workflow_editor: Get the URL to open a workflow in the browser editor

Build & app management:

list_builds: List available build versions
upload_build: Upload a local build file (.apk/.ipa/.zip) to an app
create_app: Create a new app for build uploads
delete_app: Delete an app and all its build versions

Module management:

list_modules: List reusable test modules
get_module: Get module details by ID
create_module: Create a new reusable module
delete_module: Delete a module
insert_module_block: Generate a module_import YAML snippet

Script management:

list_scripts: List code execution scripts
get_script: Get script details including source code
create_script: Create a new code execution script
update_script: Update an existing script
delete_script: Delete a script
insert_script_block: Generate a code_execution YAML snippet

Tag management:

list_tags: List all tags with test counts
create_tag: Create a new tag (upsert)
delete_tag: Delete a tag
get_test_tags: Get tags for a test
set_test_tags: Replace all tags on a test
add_remove_test_tags: Add/remove tags without replacing all

Environment variables:

list_env_vars: List env vars for a test
set_env_var: Add or update a test env var
delete_env_var: Delete a test env var by key
clear_env_vars: Delete all env vars for a test

Workflow settings:

get_workflow_settings: Get workflow location and app settings
set_workflow_location: Set GPS location override for a workflow
clear_workflow_location: Remove location override
set_workflow_app: Set app overrides for a workflow
clear_workflow_app: Remove app overrides

Live editing:

open_test_editor: Open test in browser editor with optional hot reload
stop_hot_reload: Stop the hot reload session
hot_reload_status: Check if a hot reload session is active

Utilities:

auth_status: Check authentication status
get_schema: Get CLI and YAML test schema reference

Authentication: Set REVYL_API_KEY environment variable, or run ‘revyl auth login’ first. Example Cursor configuration:

{
  "mcpServers": {
    "revyl": {
      "command": "revyl",
      "args": ["mcp", "serve"],
      "env": {
        "REVYL_API_KEY": "your-api-key"
      }
    }
  }
}

Usage: revyl mcp serve

`module`

Manage reusable test modules Manage reusable test modules (groups of test blocks). Modules are reusable building blocks that can be imported into any test via a module_import block. This avoids duplicating common flows like login, onboarding, or checkout across multiple tests. COMMANDS: list - List all modules get - Show a module’s details and blocks create - Create a new module update - Update an existing module delete - Delete a module insert - Output a module_import YAML snippet for pasting into tests EXAMPLES: revyl module list revyl module list —search login revyl module get login-flow revyl module create login-flow —from-file blocks.yaml —description “Standard login” revyl module update login-flow —name “new-name” revyl module delete login-flow revyl module insert login-flow Usage: revyl module

`module create`

Create a new module Create a new reusable module from a YAML blocks file. The blocks file should contain a top-level ‘blocks’ key with an array of test blocks: blocks:

type: instructions step_description: “Enter email in the email field”
type: instructions step_description: “Enter password in the password field”

EXAMPLES: revyl module create login-flow —from-file login-blocks.yaml revyl module create login-flow —from-file login-blocks.yaml —description “Standard login sequence” Usage: revyl module create <name> [flags] Flags:

Flag	Type	Default	Description
`--description`	string		Module description
`--from-file`	string		YAML file with blocks array

`module delete`

Delete a module Delete a module. If the module is in use by tests, the backend returns a 409 conflict error with the test names. EXAMPLES: revyl module delete login-flow revyl module delete login-flow —force Usage: revyl module delete <name|id> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`module get`

Show a module’s details and blocks Show a module’s metadata and blocks as readable YAML. EXAMPLES: revyl module get login-flow revyl module get abc-123-uuid Usage: revyl module get <name|id>

`module insert`

Output a module_import YAML snippet Output a ready-to-paste YAML snippet for importing a module into a test. EXAMPLES: revyl module insert login-flow

Output:

Paste this into your test YAML:

- type: module_import

module_id: “abc-123-uuid”

Usage: revyl module insert <name|id>

`module list`

List all modules List all modules in your organization. EXAMPLES: revyl module list revyl module list —json revyl module list —search login Usage: revyl module list [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--search`	string		Filter modules by name or description

`module restore`

Restore a module to a specific version Restore a module’s blocks and metadata to a previous version. Use ‘revyl module versions’ to see available versions first. EXAMPLES: revyl module restore login-flow —version 2 revyl module restore abc-123-uuid —version 1 Usage: revyl module restore <name|id> [flags] Flags:

Flag	Type	Default	Description
`--version`	int	0	Version number to restore to

`module update`

Update an existing module Update a module’s name, description, or blocks. EXAMPLES: revyl module update login-flow —name “new-login-flow” revyl module update login-flow —description “Updated login sequence” revyl module update login-flow —from-file updated-blocks.yaml Usage: revyl module update <name|id> [flags] Flags:

Flag	Type	Description
`--description`	string	New module description
`--from-file`	string	YAML file with new blocks array
`--name`	string	New module name

`module usage`

Show tests that use a module Show all tests that reference a module via module_import blocks. Useful before deleting or making breaking changes to a module. EXAMPLES: revyl module usage login-flow revyl module usage abc-123-uuid Usage: revyl module usage <name|id>

`module versions`

Show version history for a module Show the version history of a module, listing each version with who modified it and when. EXAMPLES: revyl module versions login-flow revyl module versions abc-123-uuid Usage: revyl module versions <name|id>

`ping`

Test API connectivity Test connectivity to the Revyl API. This command performs a simple health check against the API and reports the response time. EXAMPLES: revyl ping # Test production API revyl ping —dev # Test local development API Usage: revyl ping

`publish`

Publish to App Store / Google Play Publish apps to App Store Connect and Google Play. COMMANDS: auth - Configure store credentials testflight - Distribute to TestFlight playstore - Distribute to Google Play internal testing status - Check build processing / review status Usage: revyl publish

`publish auth`

Configure store credentials Configure credentials for App Store Connect and Google Play. COMMANDS: ios - Set up App Store Connect API key android - Set up Google Play service account status - Show configured store credentials Usage: revyl publish auth

`publish auth android`

Set up Google Play service account Configure Google Play Developer API credentials. Create a service account at: https://console.cloud.google.com/iam-admin/serviceaccounts EXAMPLE: revyl publish auth android —service-account ./service-account.json Usage: revyl publish auth android [flags] Flags:

Flag	Type	Default	Description
`--service-account`	string		Path to service account JSON key file (required)

`publish auth ios`

Set up App Store Connect API key Configure App Store Connect API credentials. Generate API keys at: https://appstoreconnect.apple.com/access/integrations/api EXAMPLE: revyl publish auth ios —key-id ABC123 —issuer-id DEF456 —private-key ./AuthKey.p8 Usage: revyl publish auth ios [flags] Flags:

Flag	Type	Description
`--issuer-id`	string	App Store Connect Issuer ID (required)
`--key-id`	string	App Store Connect API Key ID (required)
`--private-key`	string	Path to .p8 private key file (required)

`publish auth status`

Show configured store credentials Usage: revyl publish auth status

`publish playstore`

Distribute build to Google Play Upload an AAB to Google Play internal testing. EXAMPLES:

Upload to internal testing (default)

revyl publish playstore —aab ./build/app-release.aab

Upload to a specific track

revyl publish playstore —aab ./build/app-release.aab —track alpha Usage: revyl publish playstore [flags] Flags:

Flag	Type	Description
`--aab`	string	Path to the .aab file to upload (required)
`--package-name`	string	Android package name (auto-resolved from config if not specified)
`--track`	string	Release track (internal, alpha, beta, production)

`publish status`

Check build processing / review status Check the processing or review status of your latest build. EXAMPLES: revyl publish status revyl publish status —platform ios revyl publish status —build-id BUILD_ID Usage: revyl publish status [flags] Flags:

Flag	Type	Description
`--app-id`	string	App Store Connect app ID (auto-resolved from config)
`--build-id`	string	Specific build ID to check
`--platform`	string	Platform to check (ios, android)

`publish testflight`

Distribute build to TestFlight Upload and distribute an IPA to TestFlight beta groups. The command will:

Upload the IPA to App Store Connect (if —ipa is provided)
Wait for build processing
Distribute to the specified beta group(s)

EXAMPLES:

Distribute latest build to default group

revyl publish testflight

Upload and distribute

revyl publish testflight —ipa ./build/MyApp.ipa —group “Beta Testers”

Multiple groups

revyl publish testflight —ipa ./build/MyApp.ipa —group “Internal,External” Usage: revyl publish testflight [flags] Flags:

Flag	Type	Default	Description
`--app-id`	string		App Store Connect app ID (auto-resolved from config if not specified)
`--build-number`	string		Build number (auto-extracted from IPA if not specified)
`--group`	string		TestFlight beta group name(s), comma-separated
`--ipa`	string		Path to the .ipa file to upload
`--timeout`	duration	30m0s	Timeout for build processing
`--version`	string		Version string (auto-extracted from IPA if not specified)
`--wait`	bool	true	Wait for build processing to complete
`--whats-new`	string		”What to Test” notes

`sandbox`

Manage Fleet sandboxes (internal) Manage Fleet sandboxes — Mac Mini VMs with iOS simulators and Android emulators. Sandboxes are pool-based: claim one to get an isolated dev environment, then release it when you’re done. Each sandbox comes with pre-installed tools, SSH access via Cloudflare tunnels, and git worktree support. Requires —dev flag (internal feature). COMMANDS: status - Show pool availability list - List all sandboxes claim - Claim an available sandbox release - Release your sandbox back to the pool mine - Show your claimed sandbox(es) ssh - SSH into your sandbox ssh-key - Manage SSH keys on your sandbox EXAMPLES: revyl —dev sandbox status revyl —dev sandbox claim revyl —dev sandbox ssh revyl —dev sandbox release Usage: revyl sandbox

`sandbox auth`

Manage auth credentials on your sandbox Sync or wipe authentication credentials between your local machine and sandbox. COMMANDS: sync - Copy local auth configs (gh, claude, codex, git identity) to sandbox wipe - Remove all auth configs from sandbox EXAMPLES: revyl —dev sandbox auth sync revyl —dev sandbox auth wipe Usage: revyl sandbox auth

`sandbox auth sync`

Sync local auth credentials to your sandbox Copy local authentication configs to your claimed sandbox. Syncs the following:

~/.config/gh/ (GitHub CLI)
~/.claude/ (Claude AI)
~/.codex/ (Codex AI)
git user.name (git identity)
git user.email (git identity)

EXAMPLES: revyl —dev sandbox auth sync revyl —dev sandbox auth sync —json Usage: revyl sandbox auth sync

`sandbox auth wipe`

Remove all auth credentials from your sandbox Remove all authentication configs from your claimed sandbox. Removes the following:

~/.config/gh/ (GitHub CLI)
~/.claude/ (Claude AI)
~/.codex/ (Codex AI)
git user.name (git identity)
git user.email (git identity)

EXAMPLES: revyl —dev sandbox auth wipe revyl —dev sandbox auth wipe —json Usage: revyl sandbox auth wipe

`sandbox claim`

Claim an available sandbox Claim an available sandbox from the pool. The system automatically picks the best available sandbox and assigns it to you. After claiming, your SSH key is pushed for secure access. Use —allow-multiple to claim additional sandboxes when you already have one. EXAMPLES: revyl —dev sandbox claim revyl —dev sandbox claim —allow-multiple revyl —dev sandbox claim —json Usage: revyl sandbox claim [flags] Flags:

Flag	Type	Default	Description
`--allow-multiple`	bool	false	Allow claiming additional sandboxes when you already have one

`sandbox list`

List all sandboxes with status List all sandboxes in the Fleet pool with their current status. EXAMPLES: revyl —dev sandbox list revyl —dev sandbox list —json Usage: revyl sandbox list

`sandbox mine`

Show your claimed sandbox(es) Show sandboxes currently claimed by you. EXAMPLES: revyl —dev sandbox mine revyl —dev sandbox mine —json Usage: revyl sandbox mine

`sandbox open`

Open a worktree in your IDE or terminal Open a sandbox worktree in your preferred IDE via SSH remote, or open a terminal session at the worktree path. Supported editors: cursor, vscode, zed EXAMPLES: revyl —dev sandbox open feature-x —repo my-repo # Default: cursor revyl —dev sandbox open feature-x —repo my-repo —editor vscode revyl —dev sandbox open feature-x —repo my-repo —editor zed revyl —dev sandbox open feature-x —repo my-repo —terminal Usage: revyl sandbox open <branch> [flags] Flags:

Flag	Type	Default	Description
`--editor`	string		Editor to open in (cursor, vscode, zed). Default: cursor
`-n, --name`	string		Target sandbox name
`--repo`	string		Repo directory name under ~/workspace (required)
`--terminal`	bool	false	Open a terminal session instead of an IDE

`sandbox release`

Release your sandbox back to the pool Release your claimed sandbox back to the pool. If you have one sandbox, it’s released automatically. If you have multiple, specify the sandbox ID. EXAMPLES: revyl —dev sandbox release revyl —dev sandbox release <sandbox-id> revyl —dev sandbox release —force Usage: revyl sandbox release [sandbox-id] [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`sandbox ssh`

SSH into your sandbox Open an interactive SSH session to your claimed sandbox. Connects via Cloudflare tunnel for secure access. Requires cloudflared to be installed. EXAMPLES: revyl —dev sandbox ssh Usage: revyl sandbox ssh

`sandbox ssh-key`

Manage SSH keys on your sandbox Manage SSH keys for sandbox access. COMMANDS: push - Push your SSH public key to your sandbox status - Check SSH key configuration Usage: revyl sandbox ssh-key

`sandbox ssh-key push`

Push your SSH public key to your sandbox Push your SSH public key to your claimed sandbox. Reads ~/.ssh/id_ed25519.pub by default, or specify a custom key file. When you have multiple sandboxes, use —name to target a specific one. EXAMPLES: revyl —dev sandbox ssh-key push revyl —dev sandbox ssh-key push ~/.ssh/custom_key.pub revyl —dev sandbox ssh-key push —name Revyl-Mac-mini-W641QMFKQR Usage: revyl sandbox ssh-key push [key-file] [flags] Flags:

Flag	Type	Default	Description
`-n, --name`	string		Target sandbox name (required when you have multiple claimed sandboxes)

`sandbox ssh-key status`

Check SSH key configuration Check whether your SSH key is configured on your sandbox. EXAMPLES: revyl —dev sandbox ssh-key status Usage: revyl sandbox ssh-key status

`sandbox status`

Show sandbox pool availability Show the current Fleet sandbox pool status. Displays how many sandboxes are available, claimed, and in maintenance. EXAMPLES: revyl —dev sandbox status revyl —dev sandbox status —json Usage: revyl sandbox status

`sandbox tunnel`

Manage Cloudflare tunnels on your sandbox Manage Cloudflare tunnels that expose services on your sandbox to public URLs. COMMANDS: list - List active tunnels start - Start a tunnel for a port stop - Stop a tunnel EXAMPLES: revyl —dev sandbox tunnel list revyl —dev sandbox tunnel start —port 3000 revyl —dev sandbox tunnel stop —port 3000 Usage: revyl sandbox tunnel

`sandbox tunnel list`

List active tunnels on your sandbox List all active Cloudflare tunnels on your claimed sandbox. EXAMPLES: revyl —dev sandbox tunnel list revyl —dev sandbox tunnel list —json Usage: revyl sandbox tunnel list

`sandbox tunnel start`

Start a Cloudflare tunnel for a port Start a Cloudflare tunnel to expose a local port on your sandbox. Common ports: 3000 - Frontend (Next.js) 8000 - Backend (FastAPI) EXAMPLES: revyl —dev sandbox tunnel start —port 3000 revyl —dev sandbox tunnel start —port 8000 —name backend Usage: revyl sandbox tunnel start [flags] Flags:

Flag	Type	Default	Description
`--name`	string		Service name label (e.g., frontend, backend)
`--port`	int	0	Local port to tunnel (required)

`sandbox tunnel stop`

Stop a Cloudflare tunnel Stop a Cloudflare tunnel running on your sandbox. EXAMPLES: revyl —dev sandbox tunnel stop —port 3000 revyl —dev sandbox tunnel stop —all Usage: revyl sandbox tunnel stop [flags] Flags:

Flag	Type	Default	Description
`--all`	bool	false	Stop all tunnels
`--port`	int	0	Port of tunnel to stop

`sandbox worktree`

Manage git worktrees on your sandbox Manage git worktrees on your claimed sandbox. Worktrees allow multiple branches to be checked out simultaneously, each in its own directory with isolated environment and device slots. COMMANDS: list - List worktrees on your sandbox create - Create a new worktree from a branch remove - Remove a worktree setup - Re-run setup on an existing worktree EXAMPLES: revyl —dev sandbox worktree list revyl —dev sandbox worktree create feature-x revyl —dev sandbox worktree remove feature-x Usage: revyl sandbox worktree

`sandbox worktree create`

Create a new worktree on your sandbox Create a new git worktree on your claimed sandbox. Creates a new branch (or uses an existing one) and sets up the worktree with .env files, dependencies, and device slot allocation. EXAMPLES: revyl —dev sandbox worktree create feature-x revyl —dev sandbox worktree create feature-x —base staging Usage: revyl sandbox worktree create <branch> [flags] Flags:

Flag	Type	Description
`--base`	string	Base branch to create from (default: staging)
`-n, --name`	string	Target sandbox name (required when you have multiple claimed sandboxes)
`--repo`	string	Repo directory name under ~/workspace (recommended for multi-repo sandboxes)

`sandbox worktree list`

List worktrees on your sandbox List all git worktrees on your claimed sandbox. Shows branch name, path, and whether it’s the main worktree. EXAMPLES: revyl —dev sandbox worktree list revyl —dev sandbox worktree list —json Usage: revyl sandbox worktree list [flags] Flags:

Flag	Type	Default	Description
`-n, --name`	string		Target sandbox name
`--repo`	string		Repo directory name under ~/workspace (optional for multi-repo sandboxes)

`sandbox worktree remove`

Remove a worktree from your sandbox Remove a git worktree from your claimed sandbox. Stops any associated tunnels and removes the worktree directory. EXAMPLES: revyl —dev sandbox worktree remove feature-x —repo my-repo revyl —dev sandbox worktree remove feature-x —repo my-repo —force Usage: revyl sandbox worktree remove <branch> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt
`-n, --name`	string		Target sandbox name
`--repo`	string		Repo directory name under ~/workspace (required)

`sandbox worktree setup`

Re-run setup on an existing worktree Re-run the setup script on an existing worktree via SSH. Reads fleet.json from the worktree to find the setup script path (e.g. ”./scripts/worktree-setup.sh”) and executes it. Useful after pulling new changes that modify setup requirements. EXAMPLES: revyl —dev sandbox worktree setup feature-x —repo my-repo Usage: revyl sandbox worktree setup <branch> [flags] Flags:

Flag	Type	Default	Description
`-n, --name`	string		Target sandbox name
`--repo`	string		Repo directory name under ~/workspace (required)

`schema`

Output CLI schema for LLM/tooling integration Output a machine-readable schema of all CLI commands. This command introspects the CLI and outputs structured documentation that LLMs and other tools can use to understand how to use the CLI. FORMATS: json - Full JSON schema with commands, flags, examples (default) markdown - Markdown documentation suitable for docs sites llm - Single-file format optimized for LLM context windows The schema includes:

All CLI commands with their flags and examples
Common workflows for typical use cases
Complete YAML test schema for generating tests

EXAMPLES: revyl schema # JSON to stdout revyl schema —format markdown # Markdown docs revyl schema —format llm # LLM-optimized single file revyl schema > cli-schema.json # Save to file Usage: revyl schema [flags] Flags:

Flag	Type	Default	Description
`--format`	string	json	Output format: json, markdown, llm
`-h, --help`	bool	false	help for schema

`script`

Manage code execution scripts Manage code execution scripts used by code_execution blocks in tests. Scripts are sandboxed code snippets (Python, JavaScript, TypeScript, Bash) that run during test execution to perform custom logic, data validation, or API calls. COMMANDS: list - List all scripts get - Show a script’s details and code create - Create a new script from a local file update - Update an existing script delete - Delete a script usage - Show tests that use a script insert - Output a code_execution YAML snippet EXAMPLES: revyl script list revyl script list —runtime python revyl script get my-validator revyl script create my-validator —runtime python —file validate.py revyl script update my-validator —file validate.py revyl script delete my-validator revyl script usage my-validator revyl script insert my-validator Usage: revyl script

`script create`

Create a new script from a local file Create a new code execution script from a local source file. EXAMPLES: revyl script create my-validator —runtime python —file validate.py revyl script create price-check —runtime javascript —file check.js —description “Validate prices” Usage: revyl script create <name> [flags] Flags:

Flag	Type	Description
`--description`	string	Script description
`--file`	string	Path to source file
`--runtime`	string	Script runtime (python, javascript, typescript, bash)

`script delete`

Delete a script Delete a code execution script. EXAMPLES: revyl script delete my-validator revyl script delete my-validator —force Usage: revyl script delete <name|id> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`script get`

Show a script’s details and code Show a script’s metadata and source code. EXAMPLES: revyl script get my-validator revyl script get abc-123-uuid Usage: revyl script get <name|id>

`script insert`

Output a code_execution YAML snippet Output a ready-to-paste YAML snippet for using a script in a test. EXAMPLES: revyl script insert my-validator Usage: revyl script insert <name|id>

`script list`

List all scripts List all code execution scripts in your organization. EXAMPLES: revyl script list revyl script list —json revyl script list —runtime python Usage: revyl script list [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output as JSON
`--runtime`	string		Filter by runtime (python, javascript, typescript, bash)

`script update`

Update an existing script Update a script’s name, description, or code. EXAMPLES: revyl script update my-validator —file validate.py revyl script update my-validator —name “new-name” revyl script update my-validator —description “Updated validator” Usage: revyl script update <name|id> [flags] Flags:

Flag	Type	Description
`--description`	string	New script description
`--file`	string	Path to source file with updated code
`--name`	string	New script name

`script usage`

Show tests that use a script Show all tests that reference a script via code_execution blocks. EXAMPLES: revyl script usage my-validator Usage: revyl script usage <name|id>

`services`

Manage service sessions from .revyl/sessions.json Manage service sessions defined in .revyl/sessions.json. The sessions file uses the Terminal Keeper format — the same format used by the Terminal Keeper VS Code extension. This enables shared session definitions that work across: • VS Code (Terminal Keeper extension) • Fleet Dashboard (Ghostty terminal tabs) • Revyl CLI (this command) Each session profile defines a set of terminal tabs with shell commands. For example, the “default” session might start a frontend, backend, action server, and workers — all in parallel with colored log output. Run ‘revyl services docs’ for the full format reference. Usage: revyl services

`services docs`

Print the .revyl/ session format reference Print comprehensive documentation for the .revyl/ directory and session format. Usage: revyl services docs

`services list`

List available session profiles List all session profiles defined in .revyl/sessions.json. Shows each session name, the number of terminals it defines, and which session is marked as active (default). Usage: revyl services list

`services start`

Start services for a session profile Start all services defined in a session profile. Reads .revyl/sessions.json from the current repository, resolves the session name (defaults to the “active” session), and spawns each terminal’s commands as a background process. Output from all processes is streamed with colored name prefixes (similar to docker-compose). Handles SIGINT/SIGTERM to gracefully stop all spawned processes. EXAMPLES: revyl services start # Start the active/default session revyl services start “default + tools” # Start a specific session revyl services start —list # Show sessions then start one Usage: revyl services start [session] [flags] Flags:

Flag	Type	Default	Description
`-s, --service`	stringSlice	[]	Start only the named service(s). Can be repeated: -s frontend -s backend

`services status`

Show status of running services Show the status of services previously started by ‘revyl services start’. Reads the PID file at .revyl/.services.pid and checks which processes are still alive. With —json, outputs structured JSON for programmatic consumption (used by Fleet Dashboard). Usage: revyl services status

`services stop`

Stop all running services Stop all services previously started by ‘revyl services start’. Reads the PID file at .revyl/.services.pid and sends SIGTERM to each process. Falls back to SIGKILL after a brief timeout. Usage: revyl services stop [flags] Flags:

Flag	Type	Default	Description
`-s, --service`	stringSlice	[]	Stop only the named service(s). Can be repeated: -s frontend -s backend

`skill`

Manage Revyl agent skills Manage Revyl agent skills for AI coding tools. Revyl ships embedded skills:

revyl-cli, revyl-cli-create, revyl-cli-analyze, revyl-cli-dev-loop
revyl-mcp, revyl-mcp-create, revyl-mcp-analyze, revyl-mcp-dev-loop

EXAMPLES: revyl skill list revyl skill install # Default: install CLI family revyl skill install —mcp # Install MCP family revyl skill install —cli —mcp # Install both families revyl skill install —codex revyl skill show —name revyl-cli-dev-loop revyl skill show —name revyl-mcp-dev-loop revyl skill export —name revyl-mcp-create -o SKILL.md revyl skill export —name revyl-cli-analyze -o SKILL.md revyl skill revyl-cli-dev-loop install —codex Usage: revyl skill

`skill export`

Export a skill to a file Export an embedded SKILL.md to a file on disk. EXAMPLES: revyl skill export —name revyl-cli revyl skill export —name revyl-mcp-analyze revyl skill export —name revyl-mcp-dev-loop -o skills/SKILL.md revyl skill export —name revyl-cli-dev-loop -o /tmp/SKILL.md Usage: revyl skill export --name <skill-name> [flags] Flags:

Flag	Type	Default	Description
`--name`	string		Skill name to export (required)
`-o, --output`	string	SKILL.md	Output file path

`skill install`

Install Revyl agent skills for your AI coding tool Install Revyl agent skills to the appropriate directories for your AI coding tool. Without flags, auto-detects which tools are present by checking for their configuration directories. With a tool flag, installs to that specific tool’s skill directory. By default installs to the project-level directory (e.g. .cursor/skills/). Use —global to install to the user-level directory instead. EXAMPLES: revyl skill install # Auto-detect tool; install CLI skill family revyl skill install —cli # Install CLI skill family revyl skill install —mcp # Install MCP skill family revyl skill install —cli —mcp # Install both families revyl skill install —name revyl-mcp-dev-loop revyl skill install —name revyl-cli-create —name revyl-cli-analyze revyl skill install —cursor # Install for Cursor (project) revyl skill install —global # Auto-detect, install globally revyl skill install —claude # Install for Claude Code revyl skill install —codex # Install for Codex revyl skill install —force # Overwrite existing installations revyl skill revyl-mcp-dev-loop install —codex # Install via shortcut Usage: revyl skill install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family
`--name`	stringSlice	[]	Skill name(s) to install (repeatable)

`skill list`

List available embedded skills List all embedded Revyl skills that can be installed. EXAMPLES: revyl skill list Usage: revyl skill list

`skill revyl-cli`

Operations for revyl-cli Usage: revyl skill revyl-cli

`skill revyl-cli install`

Install only revyl-cli Usage: revyl skill revyl-cli install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill revyl-cli-analyze`

Operations for revyl-cli-analyze Usage: revyl skill revyl-cli-analyze

`skill revyl-cli-analyze install`

Install only revyl-cli-analyze Usage: revyl skill revyl-cli-analyze install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill revyl-cli-create`

Operations for revyl-cli-create Usage: revyl skill revyl-cli-create

`skill revyl-cli-create install`

Install only revyl-cli-create Usage: revyl skill revyl-cli-create install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill revyl-cli-dev-loop`

Operations for revyl-cli-dev-loop Usage: revyl skill revyl-cli-dev-loop

`skill revyl-cli-dev-loop install`

Install only revyl-cli-dev-loop Usage: revyl skill revyl-cli-dev-loop install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill revyl-mcp`

Operations for revyl-mcp Usage: revyl skill revyl-mcp

`skill revyl-mcp install`

Install only revyl-mcp Usage: revyl skill revyl-mcp install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill revyl-mcp-analyze`

Operations for revyl-mcp-analyze Usage: revyl skill revyl-mcp-analyze

`skill revyl-mcp-analyze install`

Install only revyl-mcp-analyze Usage: revyl skill revyl-mcp-analyze install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill revyl-mcp-create`

Operations for revyl-mcp-create Usage: revyl skill revyl-mcp-create

`skill revyl-mcp-create install`

Install only revyl-mcp-create Usage: revyl skill revyl-mcp-create install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill revyl-mcp-dev-loop`

Operations for revyl-mcp-dev-loop Usage: revyl skill revyl-mcp-dev-loop

`skill revyl-mcp-dev-loop install`

Install only revyl-mcp-dev-loop Usage: revyl skill revyl-mcp-dev-loop install [flags] Flags:

Flag	Type	Default	Description
`--claude`	bool	false	Install for Claude Code
`--cli`	bool	false	Install CLI skill family
`--codex`	bool	false	Install for Codex
`--cursor`	bool	false	Install for Cursor
`--force`	bool	false	Overwrite existing skill installations
`--global`	bool	false	Install to user-level (global) directory instead of project-level
`--mcp`	bool	false	Install MCP skill family

`skill show`

Print a skill content to stdout Print an embedded SKILL.md content to stdout. EXAMPLES: revyl skill show —name revyl-cli revyl skill show —name revyl-mcp-dev-loop revyl skill show —name revyl-cli-create | pbcopy Usage: revyl skill show --name <skill-name> [flags] Flags:

Flag	Type	Default	Description
`--name`	string		Skill name to print (required)

`sync`

Sync tests, workflows, and app links with upstream state Synchronize local project state against your Revyl organization. By default, sync reconciles tests, workflows, and app link mappings in .revyl/config.yaml. Prompts are shown only when a decision is required (conflicts, stale/deleted mappings, duplicates). EXAMPLES: revyl sync # Sync tests + workflows + app links revyl sync —tests # Sync tests only revyl sync —workflows —apps # Sync workflows and app links revyl sync —non-interactive # No prompts; deterministic defaults revyl sync —prune # Auto-prune stale mappings revyl sync —dry-run —json # Preview actions as JSON Usage: revyl sync [flags] Flags:

Flag	Type	Default	Description
`--apps`	bool	false	Sync build platform app_id links
`--bootstrap`	bool	false	Rebuild config mappings from local YAML _meta.remote_id values (useful after cloning)
`--dry-run`	bool	false	Show planned actions without writing files
`--interactive`	bool	false	Force interactive prompts (requires TTY stdin)
`--non-interactive`	bool	false	Disable prompts and apply deterministic defaults
`--prune`	bool	false	Auto-prune stale/deleted mappings
`--skip-hotreload-check`	bool	false	Skip validating hotreload platform key mappings
`--tests`	bool	false	Sync tests
`--workflows`	bool	false	Sync workflows

`tag`

Manage test tags Manage tags for organizing and categorizing tests. Tags can be created, updated, and deleted at the organization level. Tests can have multiple tags assigned to them for filtering and grouping. COMMANDS: list - List all tags with test counts create - Create a new tag update - Update a tag’s properties delete - Delete a tag get - Show tags for a specific test set - Replace all tags on a test add - Add tags to a test (keep existing) remove - Remove tags from a test EXAMPLES: revyl tag list revyl tag list —search regression revyl tag create regression —color “#22C55E” revyl tag get my-test revyl tag set my-test regression,smoke revyl tag add my-test login revyl tag remove my-test smoke Usage: revyl tag

`tag add`

Add tags to a test (keep existing) Add tags to a test without removing existing tags. Tags are auto-created if they don’t exist. EXAMPLES: revyl tag add my-test regression,smoke revyl tag add my-test login Usage: revyl tag add <test-name|id> <tag1,tag2,...>

`tag create`

Create a new tag Create a new tag. If a tag with the same name already exists, it will be returned. EXAMPLES: revyl tag create regression revyl tag create smoke —color “#22C55E” Usage: revyl tag create <name> [flags] Flags:

Flag	Type	Default	Description
`--color`	string		Tag color (hex, e.g. #22C55E)

`tag delete`

Delete a tag Delete a tag. This removes it from all tests that use it. EXAMPLES: revyl tag delete regression revyl tag delete regression —force Usage: revyl tag delete <name|id> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`tag get`

Show tags for a specific test Show all tags assigned to a specific test. EXAMPLES: revyl tag get my-test revyl tag get my-test —json Usage: revyl tag get <test-name|id> List all tags with test counts List all tags in your organization with the number of tests using each tag. EXAMPLES: revyl tag list revyl tag list —json revyl tag list —search regression Usage: revyl tag list [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--search`	string		Filter tags by name

`tag remove`

Remove tags from a test Remove specific tags from a test. EXAMPLES: revyl tag remove my-test smoke revyl tag remove my-test regression,smoke Usage: revyl tag remove <test-name|id> <tag1,tag2,...>

`tag set`

Replace all tags on a test Replace all tags on a test with the given comma-separated list. Tags are auto-created if they don’t exist. EXAMPLES: revyl tag set my-test regression,smoke revyl tag set my-test login Usage: revyl tag set <test-name|id> <tag1,tag2,...>

`tag update`

Update a tag’s properties Update a tag’s name, color, or description. EXAMPLES: revyl tag update regression —color “#22C55E” revyl tag update regression —name “regression-v2” revyl tag update regression —description “Regression test suite” Usage: revyl tag update <name|id> [flags] Flags:

Flag	Type	Description
`--color`	string	New tag color (hex)
`--description`	string	New tag description
`--name`	string	New tag name

`test`

Manage test definitions Manage local and remote test definitions. Use ‘revyl test run <name>’ to run a test, optionally with —build to build first. COMMANDS: list - List tests with sync status remote - List all tests in your organization push - Push local test changes to remote pull - Pull remote test changes to local diff - Show diff between local and remote rename - Rename a test while preserving history validate - Validate YAML test files run - Run a test (optionally with —build) cancel - Cancel a running test create - Create a new test delete - Delete a test open - Open a test in the browser status - Show latest execution status history - Show execution history report - Show detailed test report share - Generate shareable report link env - Manage app launch environment variables duplicate - Duplicate an existing test versions - List version history for a test restore - Restore a test to a specific version EXAMPLES: revyl test run login-flow # Run a test revyl test run login-flow —build # Build then run revyl test list # List tests with sync status revyl test status login-flow # Check latest execution status revyl test report login-flow # View detailed step report Usage: revyl test

`test cancel`

Cancel a running test Cancel a running test execution by its task ID. Task ID is shown when you start a test or in the report URL. Usage: revyl test cancel <task_id>

`test create`

Create a new test Create a new test and open the editor. EXAMPLES: revyl test create login-flow —platform android revyl test create checkout —platform ios Usage: revyl test create <name> [flags] Flags:

Flag	Type	Default	Description
`--app`	string		App ID to associate with the test
`--dry-run`	bool	false	Show what would be created without creating
`--force`	bool	false	Update existing test if name already exists
`--from-file`	string		Create test from YAML file (copies to .revyl/tests/ and pushes)
`--interactive`	bool	false	Create test interactively with real-time device feedback
`--module`	stringSlice	[]	Module name or ID to insert as module_import block (can be repeated)
`--no-open`	bool	false	Skip opening browser to test editor
`--platform`	string		Target platform (android, ios)
`--platform-key`	string		Build platform key for hot reload dev client
`--port`	int	8081	Port for local dev server
`--provider`	string		Hot reload provider (expo, react-native)
`--tag`	stringSlice	[]	Tag to assign after creation (can be repeated)

`test delete`

Delete a test Delete a test from Revyl and remove local files. By default removes from remote, local .revyl/tests/<name>.yaml, and config alias. Use —remote-only or —local-only to limit scope. Usage: revyl test delete <name|id> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt
`--local-only`	bool	false	Only delete local files, keep remote
`--remote-only`	bool	false	Only delete from remote, keep local files

`test diff`

Show diff between local and remote Show the differences between local and remote versions of a test. Usage: revyl test diff <name>

`test duplicate`

Duplicate an existing test Create a copy of an existing test with a new ID. Optionally provide a name for the duplicate with —name. EXAMPLES: revyl test duplicate login-flow revyl test duplicate login-flow —name “Copy of login-flow” Usage: revyl test duplicate <test> [flags] Flags:

Flag	Type	Default	Description
`--name`	string		Name for the duplicated test

`test env`

Manage test environment variables Manage app launch environment variables for a test. Env vars are encrypted at rest and automatically injected when the app launches during test execution. COMMANDS: list - List all env vars for a test set - Add or update an env var (KEY=VALUE) delete - Delete an env var by key clear - Delete ALL env vars for a test EXAMPLES: revyl test env list my-test revyl test env set my-test API_URL=https://staging.example.com revyl test env set my-test DEBUG=true revyl test env delete my-test API_URL revyl test env clear my-test Usage: revyl test env

`test env clear`

Delete ALL env vars for a test Delete all environment variables for a test. Requires —force or interactive confirmation. Usage: revyl test env clear <test-name> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`test env delete`

Delete an env var by key Usage: revyl test env delete <test-name> <KEY>

`test env list`

List all env vars for a test Usage: revyl test env list <test-name>

`test env set`

Add or update an env var Add or update an environment variable for a test. If the key already exists, its value is updated. Otherwise a new var is created. EXAMPLES: revyl test env set my-test API_URL=https://staging.example.com revyl test env set my-test “SECRET_KEY=my secret value” Usage: revyl test env set <test-name> KEY=VALUE

`test history`

Show execution history Show execution history for a test in a table format. Displays recent executions with status, duration, and step progress. Accepts test names (config aliases), display names, or UUIDs. Examples: revyl test history login-flow revyl test history login-flow —limit 20 revyl test history login-flow —json Usage: revyl test history <name|id> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--limit`	int	10	Maximum number of executions to show

`test list`

List tests with sync status List all tests showing local and remote versions. Shows sync status: synced - Local and remote are in sync modified - Local has changes not pushed outdated - Remote has changes not pulled local-only - Test exists only locally remote-only - Test exists only on remote Usage: revyl test list [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON

`test open`

Open a test in the browser Open a test in your default browser editor. EXAMPLES: revyl test open login-flow Usage: revyl test open <name> [flags] Flags:

Flag	Type	Default	Description
`--interactive`	bool	false	Edit test interactively with real-time device feedback
`--no-open`	bool	false	Skip opening browser (with —interactive: output URL and wait for Ctrl+C)
`--platform-key`	string		Build platform key for hot reload dev client
`--port`	int	8081	Port for local dev server
`--provider`	string		Hot reload provider (expo, react-native)

`test pull`

Pull remote changes to local Pull test changes from the Revyl server. If a test name is provided, only that test is pulled. Otherwise, pulls all tests that are in your local config. Use —all to discover and pull ALL tests from your organization, including those created in the app UI that aren’t in local config yet. Examples: revyl test pull # Pull all tests in local config revyl test pull login-flow # Pull specific test revyl test pull —all # Pull all org tests (including remote-only) revyl test pull —force # Force overwrite local Usage: revyl test pull [name] [flags] Flags:

Flag	Type	Default	Description
`--all`	bool	false	Pull all tests from the organization, including those not in local config
`--dry-run`	bool	false	Show what would be pulled without pulling
`--force`	bool	false	Force overwrite local

`test push`

Push local changes to remote Push local test changes to the Revyl server. If a test name is provided, only that test is pushed. Otherwise, all modified tests are pushed. Examples: revyl test push # Push all modified tests revyl test push login-flow # Push specific test revyl test push —force # Force overwrite remote Usage: revyl test push [name] [flags] Flags:

Flag	Type	Default	Description
`--dry-run`	bool	false	Show what would be pushed without pushing
`--force`	bool	false	Force overwrite remote

`test remote`

List all tests in your organization List all tests available in your Revyl organization. This shows all tests regardless of local project configuration. Useful for discovering tests or working without a local .revyl/config.yaml. When filtering by tag, a TAGS column is included in the output. Examples: revyl test remote # List all tests revyl test remote —limit 20 # Limit results revyl test remote —platform ios # Filter by platform revyl test remote —tag regression # Filter by tag Usage: revyl test remote [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--limit`	int	50	Maximum number of tests to return
`--platform`	string		Filter by platform (android, ios)
`--tag`	string		Filter by tag name

`test rename`

Rename a test without recreating it Rename a test while keeping the same remote test ID and execution history. When called with no args in a TTY, this command prompts for test selection and the new name. EXAMPLES: revyl test rename CLI-0-onboard-a cli-0-onboard-a revyl test rename login-flow smoke-login revyl test rename Usage: revyl test rename [old-name|id] [new-name] [flags] Flags:

Flag	Type	Default	Description
`--non-interactive`	bool	false	Disable prompts; requires both positional args
`-y, --yes`	bool	false	Auto-accept default rename prompts

`test report`

Show detailed test report Show a detailed test report with step-by-step breakdown. Accepts test names (shows latest execution), test UUIDs, or task/execution IDs. When given a test name, shows the report for the most recent execution. Examples: revyl test report login-flow # Latest execution report revyl test report login-flow —json # JSON output revyl test report login-flow —share # Include shareable link revyl test report login-flow —no-steps # Summary only revyl test report <task-uuid> # Report by task ID Usage: revyl test report <name|id|taskId> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--no-steps`	bool	false	Hide step breakdown
`--open`	bool	false	Open report in browser
`--share`	bool	false	Generate and print a shareable link

`test restore`

Restore a test to a specific version Restore a test to a previously saved version. Requires —version flag specifying the version number. EXAMPLES: revyl test restore login-flow —version 3 Usage: revyl test restore <test> [flags] Flags:

Flag	Type	Default	Description
`--version`	int	0	Version number to restore

`test run`

Run a test by name or ID Run a test by its alias name (from .revyl/config.yaml) or UUID. By default runs against the last uploaded build. Use —build to build and upload first. Use the test NAME or UUID, not a file path. CORRECT: revyl test run login-flow WRONG: revyl test run login-flow.yaml EXAMPLES: revyl test run login-flow # Run (no build) revyl test run login-flow —build # Build then run Usage: revyl test run <name|id> [flags] Flags:

Flag	Type	Default	Description
`--build`	bool	false	Build and upload before running test
`-b, --build-id`	string		Specific build version ID
`--device`	bool	false	Interactively select device model and OS version
`--device-model`	string		Target device model (e.g. “iPhone 16”)
`--github-actions`	bool	false	Format output for GitHub Actions
`--json`	bool	false	Output results as JSON
`--location`	string		Initial GPS location as lat,lng (e.g. 37.7749,-122.4194)
`--no-wait`	bool	false	Exit after test starts without waiting
`--open`	bool	false	Open report in browser when complete
`--os-version`	string		Target OS version (e.g. “iOS 18.5”)
`--platform`	string		Build platform key or ios/android
`--port`	int	8081	Port for local dev server
`--provider`	string		Hot reload provider (expo, react-native)
`-r, --retries`	int	1	Number of retry attempts (1-5)
`-t, --timeout`	int	3600	Timeout in seconds
`-v, --verbose`	bool	false	Show detailed monitoring output

Generate shareable report link Generate a shareable link for a test execution report. Accepts test names (uses latest execution), test UUIDs, or task/execution IDs. Examples: revyl test share login-flow revyl test share login-flow —json revyl test share <task-uuid> —open Usage: revyl test share <name|id|taskId> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--open`	bool	false	Open shareable link in browser

`test status`

Show latest execution status Show the latest execution status for a test. Displays status, duration, step progress, and report link. Accepts test names (config aliases), display names, or UUIDs. Examples: revyl test status login-flow revyl test status login-flow —json revyl test status login-flow —open Usage: revyl test status <name|id> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--open`	bool	false	Open report in browser

`test validate`

Validate YAML test files (dry-run) Validate YAML test files without creating or running them. This command checks the YAML syntax and schema compliance, reporting any errors or warnings. Use this to verify test files before committing or running them. VALIDATES:

YAML syntax
Required fields (name, platform, build.name, blocks)
Block type validity (instructions, validation, extraction, manual, if, while, code_execution)
Manual step_type validity (wait, open_app, kill_app, go_home, navigate, set_location)
Variable definitions before use ({{variable-name}} syntax)
Platform values (ios/android only)

EXIT CODES: 0 - All files valid 1 - One or more files invalid EXAMPLES: revyl test validate test.yaml # Validate single file revyl test validate tests/*.yaml # Validate multiple files revyl test validate —json test.yaml # JSON output for CI/CD Usage: revyl test validate <file> [files...] [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON

`test var`

Manage test variables ({{name}} syntax) Manage test variables for a test. Test variables use {{variable-name}} syntax in step descriptions and are substituted at runtime. Variable names must be kebab-case (lowercase letters, numbers, hyphens). These are different from env vars (revyl test env), which are encrypted and injected at app launch. COMMANDS: list - List all variables for a test get - Get a single variable’s value set - Add or update a variable (name=value) rename - Rename a variable delete - Delete a variable by name clear - Delete ALL variables for a test EXAMPLES: revyl test var list my-test revyl test var get my-test username revyl test var set my-test username=[email protected] revyl test var rename my-test old-name new-name revyl test var delete my-test username revyl test var clear my-test Usage: revyl test var

`test var clear`

Delete ALL variables for a test Delete all test variables for a test. Requires —force or interactive confirmation. Usage: revyl test var clear <test-name> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`test var delete`

Delete a variable by name Usage: revyl test var delete <test-name> <NAME>

`test var get`

Get a single variable’s value Usage: revyl test var get <test-name> <NAME>

`test var list`

List all variables for a test Usage: revyl test var list <test-name>

`test var rename`

Rename a variable Usage: revyl test var rename <test-name> <OLD-NAME> <NEW-NAME>

`test var set`

Add or update a test variable Add or update a test variable for a test. If the name already exists, its value is updated. Otherwise a new variable is created. Variable names must be kebab-case (lowercase, numbers, hyphens). Value is optional — omit the ’=’ to create a name-only variable (useful for extraction blocks that fill the value at runtime). EXAMPLES: revyl test var set my-test username=[email protected] revyl test var set my-test “password=my secret” revyl test var set my-test otp-code Usage: revyl test var set <test-name> <NAME>=<VALUE> or <NAME>

`test versions`

List version history for a test Show all saved versions for a test. EXAMPLES: revyl test versions login-flow Usage: revyl test versions <test>

`upgrade`

Upgrade Revyl CLI to the latest version Check for and install updates to the Revyl CLI. BEHAVIOR:

Detects how the CLI was installed (Homebrew, npm, pip, direct download)
Homebrew: runs brew update && brew upgrade revyl automatically
npm/pip: shows the upgrade command to run
Direct downloads: downloads and replaces the binary

FLAGS: —check Only check for updates, don’t install —force Force upgrade even if already on latest version —prerelease Include pre-release versions EXAMPLES: revyl upgrade # Check and upgrade revyl upgrade —check # Only check for updates revyl upgrade —force # Force reinstall revyl upgrade —prerelease # Include beta versions Usage: revyl upgrade [flags] Flags:

Flag	Type	Default	Description
`--check`	bool	false	Only check for updates, don’t install
`--force`	bool	false	Force upgrade even if on latest version
`--json`	bool	false	Output results as JSON
`--prerelease`	bool	false	Include pre-release versions

`version`

Show version information Usage: revyl version

`workflow`

Manage workflows Manage workflows (collections of tests). For build→run: use “revyl workflow run <name> —build” to build, upload, then run all tests in the workflow. COMMANDS: list - List all workflows info - Show workflow details (tests, overrides, config) run - Run a workflow (add —build to build and upload first) cancel - Cancel a running workflow create - Create a new workflow add-tests - Add tests to an existing workflow remove-tests - Remove tests from an existing workflow rename - Rename a workflow while preserving history delete - Delete a workflow open - Open a workflow in the browser status - Show latest execution status history - Show execution history report - Show detailed workflow report share - Generate shareable report link location - Manage stored GPS location override app - Manage stored app overrides (per platform) config - Manage run configuration (parallelism, retries) quarantine - Manage test quarantine (ignore failures in CI) EXAMPLES: revyl workflow list # List all workflows revyl workflow info smoke-tests # View tests, overrides, config revyl workflow run smoke-tests —build # Build first, then run workflow revyl workflow run smoke-tests # Run only (no build) revyl workflow status smoke-tests # Check latest execution status revyl workflow report smoke-tests # View detailed report revyl workflow create regression —tests login,checkout revyl workflow add-tests smoke-tests login-flow revyl workflow remove-tests smoke-tests checkout revyl workflow delete smoke-tests Usage: revyl workflow

`workflow add-tests`

Add tests to an existing workflow Add one or more tests to an existing workflow. Tests already in the workflow are silently skipped (no duplicates). Accepts test names (from .revyl/config.yaml) or UUIDs. EXAMPLES: revyl workflow add-tests smoke-tests login-flow revyl workflow add-tests smoke-tests login-flow checkout payment revyl workflow add-tests 550e8400-… 6ba7b810-… Usage: revyl workflow add-tests <workflow> <test1> [test2...]

`workflow app`

Manage workflow app overrides Manage the stored app overrides for a workflow. When set, these apps override individual test app configurations for matching platforms across all tests in the workflow. COMMANDS: set - Set app overrides (per platform) clear - Remove app overrides show - Show current app config EXAMPLES: revyl workflow app set my-workflow —ios <app-id> —android <app-id> revyl workflow app show my-workflow revyl workflow app clear my-workflow Usage: revyl workflow app

`workflow app clear`

Remove app overrides from a workflow Usage: revyl workflow app clear <name|id>

`workflow app set`

Set app overrides for a workflow Set stored app overrides that apply to all tests in the workflow. At least one of —ios or —android is required. EXAMPLES: revyl workflow app set my-workflow —ios <app-id> revyl workflow app set my-workflow —android <app-id> revyl workflow app set my-workflow —ios <ios-id> —android <android-id> Usage: revyl workflow app set <name|id> [flags] Flags:

Flag	Type	Default	Description
`--android`	string		Android app ID
`--ios`	string		iOS app ID

`workflow app show`

Show current app config for a workflow Usage: revyl workflow app show <name|id>

`workflow cancel`

Cancel a running workflow Cancel a running workflow execution by its task ID. This will cancel the workflow and all of its child test executions. Usage: revyl workflow cancel <task_id>

`workflow config`

Manage workflow run configuration Manage the run configuration for a workflow (parallelism, retries). COMMANDS: show - Show current run config set - Set run config values EXAMPLES: revyl workflow config show my-workflow revyl workflow config set my-workflow —parallel 3 —retries 2 Usage: revyl workflow config

`workflow config set`

Set run configuration for a workflow Set the run configuration for a workflow. At least one of —parallel or —retries must be provided. EXAMPLES: revyl workflow config set my-workflow —parallel 3 revyl workflow config set my-workflow —retries 2 revyl workflow config set my-workflow —parallel 3 —retries 2 Usage: revyl workflow config set <name|id> [flags] Flags:

Flag	Type	Default	Description
`--parallel`	int	0	Number of tests to run in parallel
`--retries`	int	0	Max retries for failed tests

`workflow config show`

Show current run configuration for a workflow Usage: revyl workflow config show <name|id>

`workflow create`

Create a new workflow Create a new workflow and open the editor. EXAMPLES: revyl workflow create smoke-tests revyl workflow create regression —tests login-flow,checkout Usage: revyl workflow create <name> [flags] Flags:

Flag	Type	Default	Description
`--dry-run`	bool	false	Show what would be created without creating
`--no-open`	bool	false	Skip opening browser to workflow editor
`--no-sync`	bool	false	Skip adding workflow to .revyl/config.yaml
`--tests`	string		Comma-separated test names or IDs to include

`workflow delete`

Delete a workflow Delete a workflow from Revyl and remove config alias. Usage: revyl workflow delete <name|id> [flags] Flags:

Flag	Type	Default	Description
`-f, --force`	bool	false	Skip confirmation prompt

`workflow history`

Show workflow execution history Show a table of past executions for a workflow. Examples: revyl workflow history smoke-tests revyl workflow history smoke-tests —limit 20 revyl workflow history smoke-tests —json Usage: revyl workflow history <name|id> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--limit`	int	10	Number of executions to show

`workflow info`

Show workflow details (tests, overrides, config) Show detailed information about a workflow including its tests, app/location overrides, run configuration, and last execution. EXAMPLES: revyl workflow info smoke-tests revyl workflow info smoke-tests —json revyl workflow info <workflow-uuid> Usage: revyl workflow info <name|id> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON

`workflow list`

List all workflows List all workflows in your organization. EXAMPLES: revyl workflow list revyl workflow list —json Usage: revyl workflow list [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON

`workflow location`

Manage workflow GPS location override Manage the stored GPS location override for a workflow. When set, this location overrides individual test locations for all tests in the workflow. COMMANDS: set - Set the GPS location override clear - Remove the location override show - Show current location config EXAMPLES: revyl workflow location set my-workflow —lat 37.7749 —lng -122.4194 revyl workflow location show my-workflow revyl workflow location clear my-workflow Usage: revyl workflow location

`workflow location clear`

Remove the location override from a workflow Usage: revyl workflow location clear <name|id>

`workflow location set`

Set the GPS location override for a workflow Set a stored GPS location that overrides individual test locations. Both —lat and —lng are required. EXAMPLES: revyl workflow location set my-workflow —lat 37.7749 —lng -122.4194 Usage: revyl workflow location set <name|id> [flags] Flags:

Flag	Type	Default	Description
`--lat`	float64	0	Latitude (-90 to 90)
`--lng`	float64	0	Longitude (-180 to 180)

`workflow location show`

Show current location config for a workflow Usage: revyl workflow location show <name|id>

`workflow open`

Open a workflow in the browser Open a workflow in your default browser editor. Usage: revyl workflow open <name>

`workflow quarantine`

Manage quarantined tests in a workflow Manage test quarantine within a workflow. Quarantined tests still run but their failures are ignored when determining overall workflow pass/fail status. Use this to unblock CI while flaky or known-broken tests are investigated. COMMANDS: add - Quarantine tests (set failure_policy to ignore_failure) remove - Unquarantine tests (set failure_policy to fail_workflow) list - Show quarantined tests in a workflow EXAMPLES: revyl workflow quarantine list smoke-tests revyl workflow quarantine add smoke-tests login-flow checkout revyl workflow quarantine remove smoke-tests login-flow Usage: revyl workflow quarantine

`workflow quarantine add`

Quarantine tests in a workflow Mark one or more tests as quarantined in a workflow. Quarantined tests still execute but their failures do not fail the workflow. EXAMPLES: revyl workflow quarantine add smoke-tests login-flow revyl workflow quarantine add smoke-tests login-flow checkout payment Usage: revyl workflow quarantine add <workflow> <test...>

`workflow quarantine list`

List quarantined tests in a workflow Show all tests in a workflow and their quarantine status. EXAMPLES: revyl workflow quarantine list smoke-tests Usage: revyl workflow quarantine list <workflow>

`workflow quarantine remove`

Remove quarantine from tests in a workflow Unquarantine one or more tests in a workflow so their failures count again. EXAMPLES: revyl workflow quarantine remove smoke-tests login-flow revyl workflow quarantine remove smoke-tests login-flow checkout Usage: revyl workflow quarantine remove <workflow> <test...>

`workflow remove-tests`

Remove tests from an existing workflow Remove one or more tests from an existing workflow. Tests not found in the workflow are silently skipped. Accepts test names (from .revyl/config.yaml) or UUIDs. EXAMPLES: revyl workflow remove-tests smoke-tests login-flow revyl workflow remove-tests smoke-tests login-flow checkout Usage: revyl workflow remove-tests <workflow> <test1> [test2...]

`workflow rename`

Rename a workflow without recreating it Rename a workflow while keeping the same workflow ID and execution history. When called with no args in a TTY, this command prompts for workflow selection and the new name. EXAMPLES: revyl workflow rename smoke-tests regression-smoke revyl workflow rename Usage: revyl workflow rename [old-name|id] [new-name] [flags] Flags:

Flag	Type	Default	Description
`--non-interactive`	bool	false	Disable prompts; requires both positional args
`-y, --yes`	bool	false	Auto-accept default rename prompts

`workflow report`

Show detailed workflow report Show a detailed workflow report with individual test results. Accepts workflow names (shows latest execution), workflow UUIDs, or task/execution IDs. Examples: revyl workflow report smoke-tests revyl workflow report smoke-tests —json revyl workflow report smoke-tests —no-tests revyl workflow report <task-uuid> Usage: revyl workflow report <name|id|taskId> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--no-tests`	bool	false	Hide individual test breakdown
`--open`	bool	false	Open report in browser

`workflow run`

Run a workflow by name or ID Run a workflow by its alias name (from .revyl/config.yaml) or UUID. Use —build to build and upload before running. Use —ios-app / —android-app to override the app for all tests in the workflow (useful for testing a specific app across platforms). EXAMPLES: revyl workflow run smoke-tests revyl workflow run smoke-tests —build revyl workflow run smoke-tests —build —platform android revyl workflow run smoke-tests —android-app <app-uuid> revyl workflow run smoke-tests —ios-app <app-uuid> —android-app <app-uuid> Usage: revyl workflow run <name|id> [flags] Flags:

Flag	Type	Default	Description
`--android-app`	string		Override Android app ID for all tests in workflow
`--build`	bool	false	Build and upload before running workflow
`--github-actions`	bool	false	Format output for GitHub Actions
`--ios-app`	string		Override iOS app ID for all tests in workflow
`--json`	bool	false	Output results as JSON
`--location`	string		Override GPS location for all tests as lat,lng (e.g. 37.7749,-122.4194)
`--no-wait`	bool	false	Exit after workflow starts without waiting
`--open`	bool	false	Open report in browser when complete
`--platform`	string		Platform to use (requires —build)
`-r, --retries`	int	1	Number of retry attempts (1-5)
`-t, --timeout`	int	3600	Timeout in seconds
`-v, --verbose`	bool	false	Show detailed monitoring output

Generate shareable workflow report link Generate a shareable link for a workflow execution report. Examples: revyl workflow share smoke-tests revyl workflow share <task-uuid> —json Usage: revyl workflow share <name|id|taskId> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--open`	bool	false	Open shareable link in browser

`workflow status`

Show workflow execution status Show the status of a workflow execution. Accepts workflow names (shows latest execution), workflow UUIDs, or task/execution IDs. Examples: revyl workflow status smoke-tests revyl workflow status smoke-tests —json revyl workflow status <task-uuid> Usage: revyl workflow status <name|id|taskId> [flags] Flags:

Flag	Type	Default	Description
`--json`	bool	false	Output results as JSON
`--open`	bool	false	Open report in browser

Common Workflows

Check authentication (do this first!)

Verify you are authenticated before running tests

revyl auth status
# If not authenticated:
revyl auth login
# Or set environment variable:
export REVYL_API_KEY=your-api-key

First-time setup

Set up Revyl for a new project

revyl auth login
revyl init
revyl test create <name>

List available tests

See what tests are available to run

revyl test list
# Or see all tests in your organization:
revyl test remote

Build and run single test

Build, upload, and run a test (full pipeline)

# Use test NAME from config, not file path:
revyl test run <name> --build
# With a specific build platform:
revyl test run <name> --build --platform android
revyl test run <name> --build --platform ios-skip-login

Run test with specific build platform

Use a named build platform from config

# List available platforms in .revyl/config.yaml under build.platforms
revyl test run login-flow --build --platform android
revyl test run login-flow --build --platform ios-skip-login
revyl workflow run smoke-tests --build --platform android

Build and run workflow

Build, upload, and run a workflow (multiple tests)

revyl workflow run <name>
# Or with a specific build platform:
revyl workflow run <name> --build --platform android

Run test without building

Run a test using existing build (no build step)

# Use test NAME from config, not file path:
revyl test run <name>

Run workflow without building

Run a workflow using existing build

revyl workflow run <name>

Run workflow with optional build

Run a workflow, optionally building first

# Without build:
revyl workflow run <name>
# With build:
revyl workflow run <name> --build --platform android

CI/CD integration

Run tests in CI with JSON output

revyl test run <name> --json
# Or for workflows:
revyl workflow run <name> --json

Validate YAML tests

Check YAML syntax before committing

revyl test validate .revyl/tests/*.yaml

MCP server for AI agents

Start MCP server for AI integration

revyl mcp serve

Revyl YAML Test Schema - LLM Reference

Purpose

This document provides a structured, machine-readable reference for generating Revyl YAML tests programmatically.

Recommended Approach for AI Test Generation

Before writing test YAML, read the app’s source code to understand screen structure, UI element labels, state transitions, and user-facing outcomes. This produces better tests than guessing from descriptions.

Critical Behavior for Test Generation

IMPORTANT: When generating tests, DO NOT include manual navigation at the start:

Mobile tests: Automatically open the app at test start
Do NOT add an “open_app” block as the first step unless testing a specific app launch scenario

Test Structure

test:
  metadata:
    name: "test-name"           # Required: Test name
    platform: "ios"             # Required: "ios" or "android"
    tags:                       # Optional: Tag names for categorization
      - "smoke"
      - "regression"
  build:
    name: "app-name"            # Required: App name from Revyl
    pinned_version: "1.0.0"     # Optional: Pin to specific version
  blocks:                       # Required: At least one block
    - type: "instructions"
      step_description: "..."

Block Types

1. instructions

Execute an action on the app.

- type: instructions
  step_description: "Tap the login button"

2. validation

Assert something is visible or true.

- type: validation
  step_description: "Verify the welcome message is displayed"

3. extraction

Extract a value from the screen into a variable.

- type: extraction
  step_description: "Extract the confirmation code from the screen"
  variable_name: "confirmation-code"  # kebab-case required

4. manual

Execute a system-level action.

# Wait for N seconds
- type: manual
  step_type: wait
  step_description: "3"  # Number of seconds

# Open app (usually not needed - app opens automatically)
- type: manual
  step_type: open_app
  step_description: "com.example.app"  # Optional bundle ID

# Kill app
- type: manual
  step_type: kill_app

# Go to home screen
- type: manual
  step_type: go_home

# Navigate to URL/deep link
- type: manual
  step_type: navigate
  step_description: "https://example.com/path"

# Set device location
- type: manual
  step_type: set_location
  step_description: "37.7749,-122.4194"  # latitude,longitude

5. if (Conditional)

Execute blocks conditionally.

- type: if
  condition: "Is the user logged in?"
  then:
    - type: instructions
      step_description: "Tap logout"
  else:
    - type: instructions
      step_description: "Tap login"

6. while (Loop)

Repeat blocks while condition is true.

- type: while
  condition: "Are there more items in the list?"
  body:
    - type: instructions
      step_description: "Scroll down"
    - type: instructions
      step_description: "Tap the next item"

7. code_execution

Execute a server-side script.

- type: code_execution
  step_description: "script-uuid-here"
  variable_name: "result"  # Optional: store result in variable

8. module_import

Import a reusable module (group of blocks) by its UUID. Modules are reusable building blocks created via the app UI or CLI. When a test runs, module_import blocks are expanded into the module’s constituent blocks at execution time.

- type: module_import
  step_description: "Login Flow"     # Module name (for readability)
  module_id: "abc-123-uuid"          # Required: Module UUID

Use revyl module list to find available modules and their IDs, or revyl module insert <name> to generate a ready-to-paste snippet.

Variable System

Syntax

Variables use double curly braces: {{variable-name}}

Naming Rules

kebab-case only: lowercase letters, numbers, hyphens
No spaces, underscores, or special characters
Must not start or end with hyphen

Usage

Variables must be defined (via extraction or code_execution) before use:

blocks:
  # First: Extract the code
  - type: extraction
    step_description: "Extract the OTP code"
    variable_name: "otp-code"
  
  # Then: Use the variable
  - type: instructions
    step_description: "Enter {{otp-code}} in the verification field"

Best Practices

1. Use High-Level Instructions

For complex flows with indeterminism, use descriptive instructions:

# Good - handles variations
- type: instructions
  step_description: "Complete the checkout process"

# Bad - too specific, may break
- type: instructions
  step_description: "Tap button at coordinates (150, 300)"

2. Validate Outcomes, Not Transient States

Validate results, not loading/transition states (spinners, progress text may vanish before capture).

3. Use Broad Validations

When exact UI elements are unknown, use flexible descriptions like “success message is shown”.

4. Use Wait Blocks Sparingly

Steps have built-in retry logic. Only add waits for known significant delays (after kill_app, system-level pauses).

5. Negative Validations

Verify errors are NOT shown:

- type: validation
  step_description: "Verify no error messages are displayed"

Pre-Generation Checklist

Before generating a test, verify:

Login steps include credentials (or use variables)
All {{variables}} are extracted before use
Validations describe VISIBLE elements
Instructions are specific enough to be actionable
Test does NOT assume pre-existing app state
Platform is specified (ios or android)
Build name matches a configured app

Complete Example

test:
  metadata:
    name: "login-and-verify-dashboard"
    platform: "ios"
    tags:
      - "smoke"
      - "auth"
  build:
    name: "my-ios-app"
  blocks:
    # Login flow
    - type: instructions
      step_description: "Enter '[email protected]' in the email field"
    
    - type: instructions
      step_description: "Enter 'password123' in the password field"
    
    - type: instructions
      step_description: "Tap the Sign In button"

    # Verify dashboard (built-in retry handles the load time)
    - type: validation
      step_description: "Verify the dashboard screen is displayed"
    
    # Extract user info
    - type: extraction
      step_description: "Extract the user's display name"
      variable_name: "user-name"
    
    # Conditional logout
    - type: if
      condition: "Is there a logout button visible?"
      then:
        - type: instructions
          step_description: "Tap the logout button"
        - type: validation
          step_description: "Verify the login screen is displayed"

Getting Started

Tests

Builds

Workflows

Monitoring

Integrations

CLI

CI/CD

Device Automation

​Global Flags

​Commands

​app

​app create

​app delete

​app list

​auth

​auth billing

​auth login

​auth logout

​auth status

​build

​build delete

​build list

​build upload

​config

​config edit

​config path

​config set

​config show

​dev

​dev start

​dev test

dev test create

dev test open

dev test run

​device

​device back

​device clear-text

​device code-execution

​device doctor

​device double-tap

​device download-file

​device drag

​device extract

​device history

​device home

​device info

​device install

​device instruction

​device key

​device kill-app

​device launch

​device list

​device long-press

​device navigate

​device open-app

​device pinch

​device report

​device screenshot

​device set-location

​device shake

​device start

​device stop

​device swipe

​device tap

​device targets

​device type

​device use

​device validation

​device wait

​docs

​doctor

​init

​mcp

​mcp serve

​module

​module create

​module delete

​module get

​module insert