# Robomori command line The `robomori` command creates, runs and controls Android emulators and physical devices from a terminal. It does what the Robomori app does, so scripts and coding agents can use it too. Emulators it starts show up in the app, and it uses the app's settings and presets. ## Install The command line comes with Robomori 1.6.0 and later. 1. Open Robomori and go to **Settings → Command Line**. 2. Next to **Add `robomori` to path**, click **Install**. On a Mac, macOS asks for your password to add the command to `/usr/local/bin`. 3. Open a new terminal and run `robomori help`. The command runs your installed copy of Robomori, so it updates along with the app. To remove it, click **Uninstall** on the same page. ## Quick start ```sh robomori emulator create pixel-10 --start # create a Pixel 10 and boot it robomori controls dark-mode on # switch it to dark theme robomori screenshot -o home.png # save a screenshot robomori emulator stop Pixel_10 ``` ## For coding agents Install the [Robomori skill](https://github.com/robomori/skills) so Claude Code, Codex, Cursor and other agents know every command and when to use it instead of adb: ```sh npx skills add robomori/skills ``` - Add `--json` to any command for machine-readable output, including errors. - Results go to standard output. Progress, such as "Starting Pixel 10…", goes to standard error. - Exit codes: `0` when the command worked, `1` when it failed, `2` when it was typed wrong. - Error messages name the next command to run, such as "Pixel_10 isn't running. Start it with 'robomori emulator start Pixel_10'." - Commands never ask questions, so nothing waits for input. - Run `robomori help `, or add `-h` to any command, for its options. ## Choosing a device Commands that act on a running device take `--device`, with a name or serial from `robomori device list`. Without it, they use, in order: 1. The device in `ANDROID_SERIAL`, the same one adb uses. 2. The device this git worktree claimed with `robomori device claim`. 3. The only running device no other worktree claimed. With several, the command lists them so you can choose. ```sh robomori device list robomori screenshot --device Pixel_10 robomori controls dark-mode on --device emulator-5556 ``` ### Agents working in parallel When several coding agents work on one computer, each in its own git worktree, give each one its own emulator with `robomori device claim`, so they don't install over and tap on each other's. Start one emulator per agent first; `claim` never starts or creates one. ```sh export ANDROID_SERIAL=$(robomori device claim) # this worktree's emulator, for adb, Gradle and robomori ./gradlew installDebug robomori screenshot -o home.png robomori device release # when done ``` ## Devices ### robomori device list Lists every device: running and stopped emulators, and physical devices connected over USB or Wi-Fi. ```sh robomori device list [--emulators | --physical] [--long] ``` - `--emulators` lists only emulators, and `--physical` only physical devices. - `--long` adds each device's display name, type and serial. ```text NAME KIND ANDROID STATE Pixel 9 physical Android 16 connected Pixel_10 emulator Android 17 running (emulator-5554) Pixel_Tablet emulator Android 16 not running ``` ### robomori device restart Restarts a running emulator or physical device and waits until Android has booted again. ```sh robomori device restart [--device ] [--no-wait] ``` ### robomori device claim Claims a running device for the current git worktree and prints its serial. Without a device, it returns the device this worktree already claimed, or else a running emulator no other worktree claimed. It never starts or creates an emulator, and never picks a physical device unless you name it. ```sh robomori device claim [] [--force] ``` - Robomori commands run in the worktree then use the claimed device without `--device`, and refuse devices other worktrees claimed. Export `ANDROID_SERIAL` with the serial so adb and Gradle use it too. - `--force` takes over a device another worktree claimed. - A claim ends with `robomori device release`, or when the device stops or restarts, or when its worktree is deleted. - `robomori device list` shows who claimed each device. ### robomori device release Gives back the devices the current worktree claimed, or only the one you name, and prints them. ```sh robomori device release [] ``` ## Emulators ### robomori emulator create Creates an emulator and prints its name. ```sh robomori emulator create [] [--name ] [--api ] [--start] ``` - `` is the hardware to copy, from `robomori profile list`. Without it, the newest Pixel phone. - `--name` is the name shown in the app. Without it, one is picked, such as "Pixel 10 (2)". - `--api` is the Android version, such as `37`. Without it, an installed version, or else the newest compatible one. Robomori downloads the version first if needed. - `--start` also starts the emulator and waits until Android has booted. ```sh robomori emulator create robomori emulator create pixel-10 --api 36 robomori emulator create pixel-tablet --name "QA tablet" --start --json ``` ### robomori emulator start Starts an emulator, waits until Android has booted, and prints its serial for `adb`. An emulator that's already running just prints its serial. Without a license, one emulator runs at a time: starting another fails and names the running one to stop. ```sh robomori emulator start [--cold] [--no-wait] ``` - `--cold` starts from scratch instead of the saved snapshot. - `--no-wait` returns as soon as the emulator is launched. ### robomori emulator open Shows an emulator in its own Robomori window and prints its serial. It starts the emulator if it isn't running, and the app if it's closed. Each emulator gets its own window, so several can be open side by side. ```sh robomori emulator open ``` Windows need a license. Without one, the emulator is shown in the app's main window. ### robomori emulator stop Stops a running emulator and waits until it has stopped. ```sh robomori emulator stop ``` ### robomori emulator delete Deletes a stopped emulator and everything on it. ```sh robomori emulator delete ``` ### robomori emulator wipe Erases everything on a stopped emulator, like a factory reset, then starts it and waits until Android has booted. ```sh robomori emulator wipe ``` ### robomori emulator fold Folds a running foldable emulator to its cover screen, and `unfold` opens it again. ```sh robomori emulator fold robomori emulator unfold ``` ## Controls ### robomori controls Shows or changes a running device's settings, the same ones as the app's device controls. Without a value, it prints the current value. Without a control, it prints them all. ```sh robomori controls [ []] [--device ] ``` - `dark-mode on|off`: dark theme. - `font-scale `: font size, one of 0.85, 1, 1.15, 1.3, 1.5, 1.8 or 2. - `locale `: language and region, such as `fr-FR` or `ja-JP`. - `talkback on|off`: the TalkBack screen reader. - `animations `: all of Android's animation scales, one of 0, 0.5, 1, 1.5, 2, 5 or 10, or `off`. Turn animations off for steadier UI tests and recordings. - `keyboard on|off`: show the on-screen keyboard while your computer's keyboard is attached. For emulators. ```sh robomori controls robomori controls font-scale 1.3 robomori controls animations off --device Pixel_10 ``` ## Simulate ### robomori simulate location Gives a running device a GPS position with `set`, and returns it to its real location with `clear`. Works on emulators and on physical devices with Android 12 or later. On a physical device, a background process keeps sending the position until you clear it; if it stops, the device returns to its real location within seconds. ```sh robomori simulate location set , [--device ] robomori simulate location clear [--device ] ``` ## Interact ### robomori press Presses a button on a running device: `back`, `home`, `recents` and `power` on phones and tablets, `crown` and `side` on watches, and `up`, `down`, `left`, `right`, `select` and `play-pause` on a TV. ```sh robomori press