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

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 so Claude Code, Codex, Cursor and other agents know every command and when to use it instead of adb:

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 <command>, 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.

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.

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.

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.

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.

robomori device restart [--device <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.

robomori device claim [<device>] [--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.

robomori device release [<device>]

Emulators

robomori emulator create

Creates an emulator and prints its name.

robomori emulator create [<profile>] [--name <name>] [--api <level>] [--start]

• <profile> 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.

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.

robomori emulator start <emulator> [--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.

robomori emulator open <emulator>

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.

robomori emulator stop <emulator>

robomori emulator delete

Deletes a stopped emulator and everything on it.

robomori emulator delete <emulator>

robomori emulator wipe

Erases everything on a stopped emulator, like a factory reset, then starts it and waits until Android has booted.

robomori emulator wipe <emulator>

robomori emulator fold

Folds a running foldable emulator to its cover screen, and unfold opens it again.

robomori emulator fold <emulator>
robomori emulator unfold <emulator>

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.

robomori controls [<control> [<value>]] [--device <device>]

• dark-mode on|off: dark theme.
• font-scale <scale>: font size, one of 0.85, 1, 1.15, 1.3, 1.5, 1.8 or 2.
• locale <tag>: language and region, such as fr-FR or ja-JP.
• talkback on|off: the TalkBack screen reader.
• animations <scale>: 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.

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.

robomori simulate location set <latitude>,<longitude> [--device <device>]
robomori simulate location clear [--device <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.

robomori press <button> [--device <device>]
robomori press back

robomori rotate

Rotates a running device's screen a quarter turn, clockwise unless you say otherwise. Emulators turn as if you turned them in your hand. Physical devices switch off auto-rotate to stay the way you turned them.

robomori rotate [clockwise | counterclockwise] [--device <device>]

Capture

robomori screenshot

Saves a screenshot of a running device and prints where.

robomori screenshot [--device <device>] [-o <file.png>]

• -o is where to save it. -o - writes the PNG to standard output. Without -o, it goes to your Desktop.

robomori record

Records a running device's screen until the duration has passed, or until you press Ctrl+C, then prints where it was saved. There's no 3-minute limit.

robomori record [--device <device>] [--duration <seconds>] [-o <file.mp4>]
robomori record --duration 30 -o checkout.mp4

Presets

robomori preset list

Lists the presets saved in the app and the controls each one changes.

robomori preset apply

Applies a preset to a running device and reports each control it changed.

robomori preset apply <preset> [--device <device>]
robomori preset apply "French, large text"

robomori preset save

Saves a running device's dark mode, font size, locale, TalkBack and animations as a preset, for the app and preset apply.

robomori preset save <name> [--device <device>]

robomori preset delete

robomori preset delete <preset>

Catalogs

robomori profile list

Lists the hardware profiles emulators are created from, such as pixel-10, pixel-10-pro-fold, pixel-tablet, pixel-watch-4-45mm and tv-1080p.

robomori image list

Lists the Android versions emulators can run on this computer, and whether each one is installed.

robomori image list [--profile <id>] [--refresh]

• --profile lists the versions for that profile's device type, such as Wear OS for a watch. Without it, phone versions.
• --refresh asks the Android SDK again instead of using the saved list.

Settings

robomori config

Reads and changes the SDK locations the app uses, from Settings → SDK Locations.

robomori config list
robomori config get <setting>
robomori config set <setting> <value>
robomori config unset <setting>

• sdk: the Android SDK folder.
• avds: where emulators are stored.
• adb, emulator, sdkmanager, avdmanager: a tool's path. Normally found in the SDK folder.

config set checks the value the same way the app does. config get adb prints the exact adb Robomori uses:

$(robomori config get adb) -s emulator-5554 install app.apk

License

Creating, starting, stopping and deleting emulators, dark mode and TalkBack are free. These need a Robomori license, as they do in the app:

• Running more than one emulator at a time, including emulators started outside Robomori
• Screenshots and recordings
• Font size, locale, animations and the on-screen keyboard
• Simulated location
• Saving and applying presets
• Restarting a device, wiping an emulator and cold starts