iPhone Mirror

io.github.nickatnight96Published by GitHub account nickatnight96v1.0.1Updated Oct 24, 2026

Drive a real iPhone via macOS iPhone Mirroring; Xcode build/test automation for sims and devices.

VerifiedSTDIODesktop onlyBrowser Automation Developer Tools

Server details

Identifier: io.github.nickatnight96/iphone-mirror-mcp
Transport: STDIO
Runtime: Desktop only
Trust: Verified
Published: Sep 16, 2026

Security note

MCP servers receive tool arguments from a conversation and may perform external actions. Review what a server can do before you enable it, and give it only the access it needs.

The registry verified the GitHub account nickatnight96 for this listing. That does not show the account is the product's maker.

SourceWeft's checks cover whether the listing is complete and the endpoint answered; they do not review the server's code or what its tools do.

Add a badge to your README

Show readers this MCP server is listed on SourceWeft. The badge links to this page.

[![Listed on SourceWeft](https://sourceweft.com/badge/mcp/io.github.nickatnight96%2Fiphone-mirror-mcp.svg)](https://sourceweft.com/mcp/io.github.nickatnight96%2Fiphone-mirror-mcp?utm_source=readme&utm_medium=badge)

Overview

AI-generated overview

A macOS-only MCP server that lets an assistant drive a paired iPhone through iPhone Mirroring, and build, test and launch Xcode apps on simulators and devices.

What you can do: Check session health and launch or restart the mirroring session, with a doctor check for permissions and input delivery. See the screen through screenshots, annotated screenshots, OCR reading, text and image finding, and screen recording. Wait for text or screen changes and scroll to elements. Send input with taps, double taps, long presses, swipes, drags, typing, pasted text, key presses, shake and batched actions. Navigate with home, app switcher, Spotlight, app launch and URL opening, and handle notifications. Build, test and collect Xcode results, and install, launch, inspect and uninstall apps on real devices and simulators.
When to use it: Use it when you want an assistant to operate a real iPhone from a Mac without jailbreaking or installing anything on the phone, for example to inspect what an app shows, run a tap-and-assert loop, or automate Xcode build, test and install workflows across simulators and devices.
Requirements: macOS 15 or later with iPhone Mirroring, paired to an iOS 18 or later iPhone that is nearby, locked and signed in to the same Apple Account. Xcode for the Xcode, device and simulator tools. Accessibility and Screen Recording permissions granted to the app that launches the server. Runs as a local process over stdio; the installer builds a release binary.

Before you install

It can see and control whatever iPhone the Mac is paired with while mirroring is active, so treat it like handing an unlocked phone to the model and run it only from trusted clients. Pasted text briefly goes onto the Mac clipboard and the clipboard can be read. The session pauses when the phone is unlocked or picked up. The bundle is ad-hoc signed but not notarized.

Installation

In SourceWeft

Open iPhone Mirror in the dashboard and add it to a workspace.
Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

iphone-mirror-mcp

[CI] [License: MIT] [Platform: macOS 15+] [Swift 6] [Listed on mcpservers.org] [Clones] [Views]

Let any LLM drive a real iPhone.

An MCP server that controls a physical iPhone through the built-in macOS iPhone Mirroring app, and automates Xcode development testing — build, test, install, and launch on simulators and devices, then operate the app on the mirrored screen with taps, swipes, typing, and OCR.

No jailbreak. Nothing installed on the phone. No XCUITest target.

run_on_iphone (build → install → launch on the paired iPhone)   → screenshot / read_screen / tap / paste_text     drive the app on-device   → wait_for_text / tap with expect / sim_log       assert what the user sees

run_on_iphone (build → install → launch on the paired iPhone)   → screenshot / read_screen / tap / paste_text     drive the app on-device   → wait_for_text / tap with expect / sim_log       assert what the user sees

63 tools. Works with Claude, GPT, Gemini, local models — anything that speaks MCP over stdio.

Quick start

The installer checks your machine, builds a release binary, verifies permissions end to end, and prints the exact config for your client.

Then, for Claude Code:

Or for any other MCP client:

json

{  "mcpServers": {    "iphone-mirror": {      "command": "/Users/YOU/.local/bin/iphone-mirror-mcp"    }  }}

{  "mcpServers": {    "iphone-mirror": {      "command": "/Users/YOU/.local/bin/iphone-mirror-mcp"    }  }}

Ask your model:

Take a screenshot of my iPhone and tell me what app is open.

Or grab the .mcpb bundle from the latest release if your client installs MCP bundles and you would rather skip the toolchain (see the caveats — it is ad-hoc signed but not notarized).

→ Full getting-started guide · per-client config

Requirements

macOS 15+ with iPhone Mirroring, paired to an iOS 18+ iPhone (nearby, locked, same Apple Account)
Xcode — for the xcode_*, device_*, and sim_* tools
Accessibility and Screen Recording permission, granted to the app that launches the server (your terminal, or the desktop app hosting your client) — details

Check everything at once:

It tests all four permissions, captures a real frame, and confirms macOS is actually delivering synthetic input — rather than just reading permission flags. Run it before you suspect anything else.

What it can do


Session & health	`status`, `doctor`, `mirror_launch`, `mirror_restart`
See the screen	`screenshot`, `annotated_screenshot` (every element boxed + numbered), `read_screen` (OCR with tappable centers), `find_text`, `find_image`, `record_screen`
Wait properly	`wait_for_text`, `wait_for_screen_change`, `scroll_to`
Input	`tap` (with `expect` verification), `double_tap`, `long_press`, `swipe`, `drag`, `type_text`, `paste_text` (emoji/CJK via clipboard), `read_clipboard`, `press_key`, `shake`, `batch`
Navigate	`home`, `app_switcher`, `spotlight`, `launch_app`, `open_url`
Notifications	`notifications`, `notification_click`
Xcode	`xcode_list`, `xcode_build`, `xcode_test`, `xcresult_attachments`
Real devices	`run_on_iphone`, `devices`, `device_install`, `device_launch`, `device_info`, `device_apps`, `device_uninstall`
Simulators	`run_on_sim` plus the full `simctl` belt — push, GPS, privacy grants, status bar, appearance, logs, media

→ Complete tool reference — all 63, with parameters, generated from the server's own catalog so it cannot drift.

Coordinate contract

Every x/y is a pixel position in the most recent screenshot, origin top-left. At input time the window bounds are re-queried and the pixel maps proportionally into the current bounds — so a window that moved or was resized between screenshot and tap still receives the tap in the right place.

Documentation


Getting started	Install → permissions → first tap
Connecting a client	Claude Code, Claude Desktop, Cursor, VS Code, Zed, Codex, Windsurf
Tool reference	All 63 tools and their parameters
Recipes	Driving an app, the on-device test loop, notifications, batching
Troubleshooting	Symptoms → causes → fixes
Architecture	How input actually reaches the phone
Limitations	What this genuinely cannot do

Known limitations

Tested, not guessed — the full list explains why.

Pinch and rotate cannot be synthesized. Trackpad gestures do not travel the CGEvent pipeline; an event tap sees nothing during a physical pinch, so there is nothing to reproduce.
One phone at a time — device switching has no scriptable menu.
The session pauses whenever the phone is unlocked or picked up. Apple's design; resuming needs it locked again.
No accessibility tree — OCR and template matching are the element model. Face ID, Control Center, and hardware buttons are unreachable, and DRM content captures black.

Security

This server can see and control whatever iPhone the Mac is paired with while mirroring is active. Treat it like handing your unlocked phone to the model. Run it only from clients you trust.

The phone locks the session the moment it is picked up or unlocked physically, which is a real kill switch. paste_text briefly places text on the Mac clipboard and restores what was there; read_clipboard reads it.

See SECURITY.md for the trust model and how to report a vulnerability.

Contributing

Issues and pull requests welcome — see CONTRIBUTING.md.

scripts/run_tests.sh                    # build + unit/protocol tests + CLI smokeMIRROR_MCP_LIVE=1 scripts/run_tests.sh  # + live tests (real window, capture, input)

scripts/run_tests.sh                    # build + unit/protocol tests + CLI smokeMIRROR_MCP_LIVE=1 scripts/run_tests.sh  # + live tests (real window, capture, input)

License

MIT

Source: README.md at commit 5a67652

Tools

SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

v1.0.1LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

Reached in the last 30 days25 pts
Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.
Auth declared10 pts
Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.
Tools listed15 pts
Answer tools/list without a credential, or ship a package that starts in a sandbox without one.
DescriptionRequired15 pts
Logo10 pts
Documentation15 pts
License10 pts