Claude In Mobile

🚀 Claude Mobile

Claude Mobile is an MCP server designed for mobile and desktop automation, supporting Android (via ADB), iOS Simulator (via simctl), Desktop (Compose Multiplatform), and Aurora OS (via audb). It's similar to Claude in Chrome, but tailored for mobile devices and desktop apps. With Claude Mobile, you can control your Android phone, emulator, iOS Simulator, Desktop applications, or Aurora OS device using natural language.

✨ Features

• Unified API: The same commands can be used across Android, iOS, Desktop, and Aurora OS.
• Smart screenshots: Automatically compressed for optimal LLM processing, eliminating oversized images.
• Annotated screenshots: Screenshots come with colored bounding boxes and numbered element labels for better visual UI understanding.
• Permission management: Programmatically grant, revoke, and reset app permissions, including Android runtime permissions and iOS privacy services.
• Device logs: Read logcat/system logs with filters for debugging purposes.
• UI interactions: Perform actions like tap, long press, and swipe by coordinates or element text.
• Text input: Type into focused fields.
• App control: Launch, stop, and install apps.
• Platform selection: Explicitly target Android, iOS, Desktop, or Aurora OS.
• Desktop support: Test Compose Multiplatform desktop apps with window management, clipboard, and performance metrics.

📦 Installation

One-liner (any client)

Use add-mcp to auto-detect installed clients:

npx add-mcp claude-in-mobile -y

Or target a specific client:

npx add-mcp claude-in-mobile -a claude-code -y
npx add-mcp claude-in-mobile -a opencode -y
npx add-mcp claude-in-mobile -a cursor -y

Claude Code CLI

claude mcp add --transport stdio mobile -- npx -y claude-in-mobile

To add globally (available in all projects):

claude mcp add --scope user --transport stdio mobile -- npx -y claude-in-mobile

OpenCode

Use the interactive setup:

opencode mcp add

Or add manually to opencode.json (project root or ~/.config/opencode/opencode.json):

{
  "mcp": {
    "mobile": {
      "type": "local",
      "command": ["npx", "-y", "claude-in-mobile"],
      "enabled": true
    }
  }
}

Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "mobile": {
      "command": "npx",
      "args": ["-y", "claude-in-mobile"]
    }
  }
}

Any MCP Client

Print a config snippet for your client:

npx claude-in-mobile --init <client-name>
# Supported: opencode, cursor, claude-code

From npm

npx claude-in-mobile

From source

git clone https://github.com/AlexGladkov/claude-in-mobile.git
cd claude-in-mobile
npm install
npm run build:all  # Builds TypeScript + Desktop companion

Note: For Desktop support, you need to run npm run build:desktop (or build:all) to compile the Desktop companion app.

Using a local build with MCP clients

After building from source, point your MCP client to the local dist/index.js instead of using npx:

{
  "mcpServers": {
    "mobile": {
      "command": "node",
      "args": ["/path/to/claude-in-mobile/dist/index.js"]
    }
  }
}

For OpenCode (opencode.json):

{
  "mcp": {
    "mobile": {
      "type": "local",
      "command": ["node", "/path/to/claude-in-mobile/dist/index.js"],
      "enabled": true
    }
  }
}

Manual configuration

Add to your Claude Code settings (~/.claude.json or project settings):

{
  "mcpServers": {
    "mobile": {
      "command": "npx",
      "args": ["-y", "claude-in-mobile"]
    }
  }
}

Windows

claude mcp add --transport stdio mobile -- cmd /c npx -y claude-in-mobile

Requirements

Android

• ADB must be installed and added to the PATH.
• A connected Android device with USB debugging enabled or an emulator is required.

iOS

• macOS with Xcode installed.
• iOS Simulator (physical device support is not available yet).
• WebDriverAgent is needed for full UI inspection and element-based interaction:

  npm install -g appium
  appium driver install xcuitest
  

  Or set the WDA_PATH environment variable to the custom WebDriverAgent location.

Desktop

• macOS (Windows/Linux support is planned).
• JDK 17+ is required for building the Desktop companion.
• A Compose Multiplatform desktop application for testing is needed.

Aurora OS

• audb CLI must be installed and added to the PATH (cargo install audb-client).
• A connected Aurora OS device with SSH enabled.
• Python must be installed on the device for tap/swipe operations: devel-su pkcon install python.

Available Tools

Core Tools (All Platforms)

Desktop-Specific Tools

For detailed Desktop API documentation, see Desktop Specification

💻 Usage Examples

Basic Usage

Just communicate with Claude naturally:

"Show me all connected devices"
"Take a screenshot of the Android emulator"
"Take a screenshot on iOS"
"Tap on Settings"
"Swipe down to scroll"
"Type 'hello world' in the search field"
"Press the back button on Android"
"Open Safari on iOS"
"Switch to iOS simulator"
"Run the app on both platforms"

Permission Management

"Grant camera permission to com.example.app on Android"
"Revoke location access from com.example.app"
"Reset all permissions for com.apple.Maps on iOS"

Annotated Screenshots

"Take an annotated screenshot"  → Screenshot with green (clickable) and red (non-clickable) bounding boxes + numbered element index

Platform Selection

You can explicitly specify the platform:

"Screenshot on android"     → Uses Android device
"Screenshot on ios"         → Uses iOS simulator
"Screenshot on desktop"     → Uses Desktop app
"Screenshot on aurora"      → Uses Aurora OS device
"Screenshot"                → Uses last active device

Or set the active device:

"Use the iPhone 15 simulator"
"Switch to the Android emulator"
"Switch to desktop"
"Switch to Aurora device"

Desktop Examples

"Launch my desktop app from /path/to/app"
"Take a screenshot of the desktop app"
"Get window info"
"Resize window to 1280x720"
"Tap at coordinates 100, 200"
"Get clipboard content"
"Set clipboard to 'test text'"
"Get performance metrics"
"Stop the desktop app"

Aurora Examples

"List all Aurora devices"
"Take a screenshot on Aurora"
"Tap at coordinates 100, 200 on Aurora"
"Launch ru.example.app on Aurora"
"List installed apps on Aurora device"
"Get logs from Aurora device"
"Push file.txt to /home/defaultuser/ on Aurora device"

Native CLI

A 2 MB native Rust binary that supports all the same commands. It doesn't require Node.js or any dependencies.

Install CLI

brew tap AlexGladkov/claude-in-mobile
brew install claude-in-mobile

Or download from Releases.

Advantages over MCP

• Easy install: Use brew install or copy a single 2 MB binary.
• No dependencies: No Node.js, npm, or other dependencies.
• Use from terminal: Run commands directly without the need for Claude Code or an MCP client.
• Test automation: Write universal .sh scripts for any platform without learning platform internals.
• Token-efficient: Skill documentation loads only when used; MCP loads all tool schemas into every request, which can quickly consume tokens over a session.
• Fast: ~5ms command startup (Rust) compared to ~500ms (Node.js MCP).
• CI/CD ready: Supports exit codes, stdout/stderr, and can run anywhere.

Test script example

#!/bin/bash
claude-in-mobile launch android com.example.app
claude-in-mobile wait 2000
claude-in-mobile tap android 0 0 --text "Login"
claude-in-mobile input android "test@example.com"
claude-in-mobile screenshot android -o result.png
claude-in-mobile ui-dump android | grep "Welcome" && echo "PASS" || echo "FAIL"

Claude Code Plugin

claude plugin marketplace add AlexGladkov/claude-in-mobile
claude plugin install claude-in-mobile@claude-in-mobile

After installation, Claude Code can control devices using natural language. The skill is loaded into the context only when needed, avoiding token overhead when not in use.

See cli/README.md for full CLI documentation.

iOS WebDriverAgent Setup

For full iOS UI inspection and element-based interaction, WebDriverAgent is required. It enables the following features:

• get_ui: JSON accessibility tree inspection
• tap with label or text parameters: Element-based tapping
• find_element: Element discovery and querying
• swipe: Improved gesture simulation

Installation

Automatic (via Appium):

npm install -g appium
appium driver install xcuitest

Manual: Set the WDA_PATH environment variable to your WebDriverAgent location:

export WDA_PATH=/path/to/WebDriverAgent

First Use

On first use, WebDriverAgent will be automatically:

1. Discovered from the Appium installation or WDA_PATH.
2. Built with xcodebuild (one-time, approximately 2 minutes).
3. Launched on the iOS simulator.
4. Connected via HTTP on port 8100+.

Troubleshooting

Build fails:

# Install Xcode command line tools
xcode-select --install

# Accept license
sudo xcodebuild -license accept

# Set Xcode path
sudo xcode-select -s /Applications/Xcode.app

Session fails:

• Ensure the simulator is booted: xcrun simctl list | grep Booted
• Check port availability: lsof -i :8100
• Try restarting the simulator

Manual test:

cd ~/.appium/node_modules/appium-xcuitest-driver/node_modules/appium-webdriveragent
xcodebuild test -project WebDriverAgent.xcodeproj \
  -scheme WebDriverAgentRunner \
  -destination 'platform=iOS Simulator,id=<DEVICE_UDID>'

How It Works

┌─────────────┐     ┌──────────────────┐     ┌─────────────────┐
│ Claude Code │────▶│                  │────▶│  Android (ADB)  │
├─────────────┤     │  Claude Mobile   │     └─────────────────┘
│  OpenCode   │────▶│   MCP Server     │     ┌─────────────────┐
├─────────────┤     │                  │────▶│ iOS (simctl+WDA)│
│   Cursor    │────▶│  (auto-detects   │     └─────────────────┘
├─────────────┤     │   client via     │     ┌─────────────────┐
│  Any MCP    │────▶│   MCP protocol)  │────▶│ Desktop (Compose)│
│   Client    │     │                  │     └─────────────────┘
└─────────────┘     │                  │     ┌─────────────────┐
                    │                  │────▶│ Aurora (audb)   │
                    └──────────────────┘     └─────────────────┘

1. Claude sends commands through the MCP protocol.
2. The server routes the commands to the appropriate platform (ADB, simctl+WDA, Desktop companion, or audb).
3. The commands are executed on your device or desktop app.
4. Results (screenshots, UI data, metrics) are returned to Claude.

📄 License

This project is licensed under the MIT license.