Mirroir – AI iPhone Control via macOS iPhone Mirroring

TL;DR

TL;DR: Mirroir is an open-source MCP server (Apache-2.0) that lets any AI agent control a real iPhone through macOS iPhone Mirroring — giving it screenshot access, tap/swipe gestures, and app control with 33 tools.

Source and Accuracy Notes

• Project page: mirroir.dev ← visited and verified
• Source repository: github.com/jfarcand/mirroir-mcp ← read README end-to-end
• License: Apache-2.0 (verified via LICENSE file)
• npm package: npmjs.com/package/mirroir-mcp — v0.35.0
• HN launch thread: news.ycombinator.com/item?id=47049130

What Is Mirroir?

Mirroir is an MCP server that bridges any MCP-compatible AI agent to a real iPhone via macOS iPhone Mirroring. The agent sees the screen via screenshot/OCR, decides what to do, then executes taps, swipes, and keystrokes through the server. No scripts, no coordinates — just intent.

“Give your AI eyes, hands, and a real iPhone.”

The project is not a GitHub repo that wraps an existing tool. It is a standalone MCP server built on macOS iPhone Mirroring APIs, with 33 tools covering screenshots, touch input, system gestures, app launching, and recording.

Key facts

• Package: mirroir-mcp on npm (v0.35.0)
• License: Apache-2.0
• Stars: 131
• Requirements: macOS 15+, iPhone connected via iPhone Mirroring
• Client support: Claude Code, Cursor, GitHub Copilot, OpenAI Codex

Setup Workflow

Step 1: Install Mirroir

Choose one of three install methods:

Install script (recommended):

/bin/bash -c "$(curl -fsSL https://mirroir.dev/get-mirroir.sh)"
```bash

**Or via npx:**

```bash
npx -y mirroir-mcp install
```bash

**Or via Homebrew:**

```bash
brew tap jfarcand/tap && brew install mirroir-mcp
```bash

### Step 2: Grant Permissions

The first time you take a screenshot, macOS will prompt for:

- **Screen Recording** permission
- **Accessibility** permission

Grant both in **System Settings → Privacy & Security → Screen Recording** and **Accessibility**.

### Step 3: Connect Your iPhone

Enable iPhone Mirroring on your Mac (macOS 15+):

1. Open **Control Center** on your iPhone
2. Tap **iPhone Mirroring** and select your Mac
3. Confirm the connection on both devices

### Step 4: Add to Your AI Client

#### Claude Code

```bash
claude mcp add --transport stdio mirroir -- npx -y mirroir-mcp
```bash

#### Cursor

Add to `.cursor/mcp.json` in your project root:

```json
{
  "mcpServers": {
    "mirroir": {
      "command": "npx",
      "args": ["-y", "mirroir-mcp"]
    }
  }
}
```bash

#### GitHub Copilot (VS Code)

Search `@mcp mirroir` in the Extensions view, or add to `.vscode/mcp.json`:

```json
{
  "servers": {
    "mirroir": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "mirroir-mcp"]
    }
  }
}
```bash

#### OpenAI Codex

```bash
codex mcp add mirroir -- npx -y mirroir-mcp
```bash

Or add to `~/.codex/config.toml`:

```toml
[mcp_servers.mirroir]
command = "npx"
args = ["-y", "mirroir-mcp"]
```bash

### Step 5: Verify the Connection

Run this in your AI client's terminal to confirm Mirroir is connected:

```bash
# Ask your agent to list available tools
# It should show mirroir tools: screenshot, describe_screen, tap, swipe, etc.

How It Works

Every interaction follows the same observe, reason, act loop:

1. describe_screen — captures the screen and returns every UI element with tap coordinates (the AI’s “eyes”)
2. LLM reasoning — decides what action to take next (the “brain”)
3. tap, type_text, swipe — execute the action (the “hands”)
4. Loop back to step 1

Beyond basic taps, the server exposes 33 tools including:

Tool	What it does
screenshot	Capture the iPhone screen as base64 PNG
describe_screen	Analyze screen, return UI elements with tap coordinates
tap / double_tap / long_press	Tap at coordinates
swipe	Swipe between two points
drag	Slow sustained drag for sliders, icons
type_text	Send keystrokes to the iPhone
press_key	Send special keys (return, escape, tab, arrows) with modifiers
launch_app	Open app by name via Spotlight
open_url	Open URL in Safari
press_home / press_app_switcher / spotlight	System gesture controls
press_back	Navigate back by OCR-tapping the back chevron
scroll_to	Scroll until target text becomes visible
reset_app	Force-quit an app via App Switcher
set_network	Toggle connectivity through Settings
measure	Time how long an action takes
start_recording / stop_recording	Video recording of the mirrored screen
list_targets / switch_target	Multi-device support

Practical Evaluation Checklist

• macOS 15+ with iPhone Mirroring enabled
• iPhone connected via iPhone Mirroring
• Screen Recording + Accessibility permissions granted
• At least one MCP-compatible client installed (Claude Code, Cursor, Codex, Copilot)
• mirroir-mcp added to the client’s MCP configuration
• Ran a simple task: launch an app, tap a button, read screen text

Security Notes

• Mirroir requires Screen Recording and Accessibility permissions — both are full system-level access on macOS
• Only install from the official project (npm, Homebrew tap, or GitHub) — verify the install script URL
• The iPhone Mirroring connection is local; no cloud dependency for core functionality
• Community-contributed skills are available at github.com/jfarcand/mirroir-skills — review before running any third-party automation flows

FAQ

Q: Does this work on Windows or Linux? A: No. Mirroir is built on macOS iPhone Mirroring, which is a macOS-only feature. It will not work on Windows or Linux.

Q: Do I need a developer account? A: No developer account is required. iPhone Mirroring is a consumer feature built into iOS 17+ and macOS 15+.

Q: Can multiple iPhones be connected at once? A: Yes — the list_targets and switch_target tools let you manage multiple mirrored iPhones.

Q: Is the iPhone jailbroken? A: No jailbreak required. It uses the official macOS iPhone Mirroring framework.

Q: Does the AI see the actual screen or just a description? A: The describe_screen tool returns both a screenshot (base64 PNG) and a structured list of UI elements with coordinates. The screenshot tool returns the raw image.

Q: What MCP clients are officially supported? A: Claude Code, Cursor, GitHub Copilot (VS Code), and OpenAI Codex. The project is MCP-compliant so other MCP clients may work as well.

Conclusion

Mirroir solves the “AI agent can’t interact with mobile apps” problem by bridging to a real iPhone through macOS iPhone Mirroring. With 33 tools covering every input modality — taps, swipes, typing, gestures, and screen recording — it gives agents the same control a human user would have. If you are building AI agents that need to automate iOS app interactions, this is currently the only open-source MCP server purpose-built for that task.