Dokumentation
Mobdev
Mobdev bringt deine iPhones, iOS-Simulatoren und Android-Geräte in einer Mac-App zusammen, für dich und deinen KI-Agenten. Es liest den iPhone-Bildschirm über USB. Im Entwicklermodus tippt, schreibt und liest den UI-Baum ein kleiner UI-Test, den Mobdev auf dem iPhone am Laufen hält, über dasselbe Kabel; ohne ihn tippt und schreibt Mobdev als Bluetooth-Tastatur und -Zeiger. Simulatoren und Android brauchen nur Xcode oder adb. Agenten nutzen es über MCP oder HTTP.
Installation
Du brauchst einen Mac mit macOS 26 oder neuer und Xcode, ein iPhone im Entwicklermodus und ein USB-Datenkabel. Ohne Entwicklermodus braucht der Mac Bluetooth LE. Lade die App herunter, öffne das Disk-Image und ziehe Mobdev in den Ordner „Programme“. Sie ist von Apple signiert und notarisiert und aktualisiert sich selbst.
Erlaube die Kamera, wenn macOS fragt, und auf dem Weg ohne Entwicklermodus auch Bluetooth. macOS behandelt den iPhone-Bildschirm wie eine Kamera, deshalb fragt es nach dem Kamerazugriff. Selbst bauen kannst du die App mit Xcode 26 oder neuer:
git clone https://github.com/niklas-schmidt-dev/mobdev
cd mobdev/macos
scripts/build-app.sh
open build/Mobdev.appiPhone einrichten
Der Einrichtungsassistent hakt jeden Schritt ab, sobald der Mac ihn erkennt.
- Schließe das iPhone an, entsperre es und tippe auf Vertrauen. Fragt der Mac, ob er das Zubehör erlauben soll, klicke auf „Erlauben“.
- Aktiviere Einstellungen › Datenschutz & Sicherheit › Entwicklermodus und starte das iPhone neu. Der Schalter erscheint, sobald das iPhone einmal mit Xcode verbunden war.
- Melde dich in Xcode unter Xcode › Settings › Apple Accounts mit deinem Apple Account an. Ein kostenloser Account genügt.
- Mobdev baut Mobdev Runner, einen kleinen UI-Test, und startet ihn von selbst auf dem iPhone; der erste Build dauert ein bis zwei Minuten. Fragt iOS danach, aktiviere Einstellungen › Entwickler › UI-Automatisierung aktivieren. Mit einem kostenlosen Account vertraust du dem Entwickler einmal unter Einstellungen › Allgemein › VPN und Geräteverwaltung.
- Stelle „Automatische Sperre“ auf „Nie“, solange Agenten arbeiten. Das iPhone muss entsperrt bleiben.
Ohne Entwicklermodus
Wähle im Einrichtungsassistenten „Without Developer Mode“. Mobdev tippt und schreibt dann als Bluetooth-Tastatur und -Zeiger und installiert nichts auf dem iPhone.
- Öffne auf dem iPhone Einstellungen › Bluetooth und tippe unter „Andere Geräte“ auf deinen Mac. iOS zeigt ihn unter dem Namen des Macs an. Fehlt er, warte einen Moment oder klicke in Mobdev auf Show on iPhone Again: Ein iPhone mit demselben Apple Account übersieht den Mac womöglich, bis Mobdev ihn erneut anbietet.
- Aktiviere Einstellungen › Bedienungshilfen › Tippen › AssistiveTouch. AssistiveTouch macht aus dem Zeiger Tippgesten. Deaktiviere auf derselben Seite Am Objekt einrasten und lass Berührungsgesten ausführen eingeschaltet, sonst wird jedes Wischen zum Tippen.
- Wähle in Mobdev das Tastaturlayout, das auf dem iPhone unter Einstellungen › Allgemein › Tastatur › Hardwaretastatur eingestellt ist.
Agenten verbinden
Die App zeigt diese Konfigurationen mit den richtigen Pfaden unter „Connect“. Sie enthalten keine Geheimnisse.
Claude Code
claude mcp add --scope user mobdev -- /Applications/Mobdev.app/Contents/MacOS/Mobdev mcpClaude-Code-Plugin, mit den Skills
/plugin marketplace add niklas-schmidt-dev/mobdev
/plugin install mobdev@mobdevCodex (~/.codex/config.toml)
[mcp_servers.mobdev]
command = "/Applications/Mobdev.app/Contents/MacOS/Mobdev"
args = ["mcp"]Claude Desktop, Cursor und andere
{
"mcpServers": {
"mobdev": {
"command": "/Applications/Mobdev.app/Contents/MacOS/Mobdev",
"args": ["mcp"]
}
}
}HTTP-Clients können http://127.0.0.1:4686/mcp mit dem Token aus „Settings › API“ in der App nutzen. Der Server spricht MCP 2026-07-28 und ältere Versionen bis zurück zu 2024-11-05.
Im Terminal
Jedes Tool läuft auch in einer Shell, für Skripte und für Agenten, die ein Terminal MCP vorziehen. Mobdev tools listet sie auf; Werte sind JSON, wo sie sich als JSON lesen lassen. Es geht über die laufende App und erreicht so auch iPhones, und mit gestarteten Simulatoren und Android-Geräten funktioniert es auch ohne sie.
M=/Applications/Mobdev.app/Contents/MacOS/Mobdev
$M observe
$M tap_mark mark=4
$M type_text text="hello world" submit=true
$M screenshot --image screen.pngTools
Koordinaten sind Pixel des Bildes, das screenshot zurückgibt (lange Kante 1280 px). Aktionen liefern einen neuen Screenshot, außer du übergibst "screenshot": false. Bei mehr als einem Gerät wählst du mit device (eine ID oder ein Name aus list_devices) eines aus. Ohne diese Angabe nimmt Mobdev das einzige Gerät oder, wenn daneben Simulatoren oder Android-Geräte laufen, das angeschlossene iPhone.
| Tool | Argumente | Was es tut |
|---|---|---|
| list_devices | iPhones, Simulatoren und Android-Geräte: ID, Name, Modell, Systemversion, bereit | |
| status | Bereitschaft von Bildschirm und Eingabe, Größe des Screenshots | |
| screenshot | JPEG des Bildschirms | |
| tap | x, y | Auf einen Punkt des Screenshots tippen |
| long_press | x, y, seconds | Berühren und halten |
| swipe | from_x, from_y, to_x, to_y, duration | Ziehen, z. B. zum Scrollen |
| pinch | scale, x, y, duration | Zwei Finger auseinander oder zusammen, z. B. zum Zoomen einer Karte oder eines Fotos |
| scroll | direction, amount, x, y | Mausrad |
| type_text | text, submit | Text in das fokussierte Feld eingeben (bis zu 1000 Zeichen pro Aufruf) |
| type_secret | name, submit | Ein gespeichertes Passwort oder einen Code tippen, ohne dass der Agent den Wert sieht |
| list_secrets | Die Namen der gespeicherten Secrets, nie ihre Werte | |
| press_key | key, modifiers | z. B. space + cmd für Spotlight |
| home | Zum Home-Bildschirm wechseln | |
| open_app | name | Eine App über ihren Namen oder ihre Bundle-ID öffnen (per Spotlight auf einem iPhone ohne Entwicklermodus) |
| read_screen | Gesamter sichtbarer Text mit Positionen (lokale Texterkennung) | |
| find_text | text | Wo eine Beschriftung steht |
| tap_text | text, index | Auf eine sichtbare Beschriftung tippen |
| wait_for_text | text, timeout, gone | Warten, bis ein Text erscheint oder verschwindet |
| observe | image, contains | Der Bildschirm als nummerierte Marken, günstiger als ein Screenshot; image zeichnet sie auf einen |
| tap_mark | mark | Eine Marke aus dem letzten observe antippen |
| scroll_until_visible | text, id, direction, max_scrolls | Scrollen, bis etwas erscheint; hält am Ende der Liste an |
| wait_for_idle | timeout, stable | Warten, bis sich der Bildschirm nicht mehr ändert |
| press_button | button | Lautstärke, Stumm, Wiedergabe/Pause; Sperren auf Simulatoren und Android |
| start_recording | path | Den Bildschirm als .mp4 aufnehmen, standardmäßig ins Projekt |
| save_screenshot | path | Den Bildschirm in voller Auflösung in die Screenshots des Projekts speichern, etwa für den App Store |
| stop_recording | Die Aufnahme beenden und sagen, wo sie liegt | |
| recent_steps | count, clear | Die neuesten Aktionen, die geklappt haben, als Schritte für einen Test |
| run_shortcut | name | Einen Kurzbefehl aus Apples Kurzbefehle-App ausführen |
| ui_tree | contains, all | Elemente aus dem Accessibility-Baum (Simulatoren, Android, iPhones im Entwicklermodus) |
| tap_element | id, text, regex, role, value, enabled, region, near, index, timeout | Auf ein Element tippen, per Identifier, Label, Rolle, Zustand oder dem Label daneben |
| wait_for_element | id, text, regex, role, value, enabled, region, near, timeout, gone | Warten, bis ein Element erscheint oder verschwindet |
| run_flow | path, steps, variables, video | Einen Flow abspielen (JSON oder Maestro-YAML); stoppt beim ersten fehlgeschlagenen Schritt und kann ein Video speichern |
| assert_screenshot | name, threshold, mask, update | Den Bildschirm mit einem Referenzbild vergleichen; schlägt mit einem Differenzbild fehl |
| accessibility_audit | image, fail_on, ignore | Fehlende Beschriftungen, zu kleine Tippflächen, schwacher Kontrast und unklare Beschriftungen |
| assert_with_ai | question, expect | Apple Intelligence auf dem Mac eine Ja/Nein-Frage zum Bildschirm stellen |
| crawl_app | bundle_id, max_actions, seconds, avoid | Eine App selbstständig erkunden und jeden Absturz mit seinen Schritten festhalten |
| navigate_to | bundle_id, screen | Zu einem Bildschirm gehen, den crawl_app erfasst hat |
| list_projects | Die Projekte, die Mobdev kennt, welches aktiv ist und welches deine Aufrufe nutzen | |
| create_project | path, name, bundle_id, builds | Ein Projekt im Repository der App anlegen und aktiv machen |
| open_project | project | Ein Projekt aktiv machen: über seinen Ordner, ein Repository mit mobdev/ oder seinen Namen |
| run_tests | project, tests, variables, video, language | Die Tests eines Projekts ausführen: jedes Ergebnis, der Bildschirm des ersten Fehlschlags, results.json und junit.xml |
| list_tests | project | Die Tests eines Projekts und seine neuesten Ergebnisse |
| save_test | project, name, steps, description, platforms, file | Einen Test in ein Projekt schreiben; legt es bei Bedarf an |
| save_flow | project, name, steps, file | Einen Flow in den Ordner flows/ des Projekts schreiben |
| test_result | project, run | Die Ergebnisse des neuesten Laufs mit Schritt, Screenshot und Video jedes Fehlschlags |
| run_native_tests | project, platform, only, scheme, test_plan, task, wait, … | Die eigene XCTest-, Swift-Testing- oder Gradle-Suite der App auf dem Gerät ausführen, im Hintergrund |
| native_test_result | project, run | Der Fortschritt eines nativen Laufs, sonst jeder Fehlschlag mit Datei, Zeile und Anhängen |
observe ist für einen Agenten der günstigste Blick auf den Bildschirm: eine nummerierte Liste dessen, was sich lesen oder antippen lässt, etwa [4] Button "Sign in" id=login, aus dem UI-Baum oder, wo es keinen gibt, aus der Texterkennung. tap_mark tippt einen Eintrag über seine Nummer an. wait_for_idle ersetzt feste Pausen nach Animationen, und scroll_until_visible ersetzt geratene Wischgesten.
tap_element und wait_for_element kombinieren einen Identifier, ein Label oder eine Regex mit Rolle, Wert, Aktivierungszustand, einem Bereich des Bildschirms und dem Label daneben. {"role": "textfield", "near": {"text": "Email", "direction": "below"}} ist das Feld unter „Email“, auf iOS genauso wie auf Android. Passt nichts, nennt die Fehlermeldung, was auf dem Bildschirm ist.
Passwörter und Codes von Testkonten kommen unter Settings › Secrets oder mit Mobdev secret set in Mobdev. Agenten tippen sie mit type_secret und sehen immer nur den Namen, auch in aufgezeichneten Flows und in der Activity. Die Secrets eines Testprojekts nehmen das gespeicherte Secret mit demselben Namen.
Inspect in der Symbolleiste eines Geräts zeigt Kennung und Beschriftung des Elements unter dem Zeiger, und ein Klick kopiert den Schritt, der es antippt, fertig für einen Flow oder Test.
Gerätezustand
Tests und Agenten stellen eine Situation direkt her, statt sich durch die Einstellungen zu tippen: einen Standort oder eine Route, Berechtigungen, eine Push-Mitteilung, Dunkelmodus und Schriftgröße, die Sprache, eine aufgeräumte Statusleiste für Screenshots, Face ID, die Daten einer App und die Ausrichtung. Simulatoren und Android können fast alles davon; ein iPhone im Entwicklermodus übernimmt über Xcode 27 Standort, Darstellung, Statusleiste, Zwischenablage und Ausrichtung.
| Tool | Argumente | Was es tut |
|---|---|---|
| set_location | latitude, longitude, route, speed, clear | Ein simulierter Standort oder eine Route, der das Gerät folgt |
| set_permission | bundle_id, permission, state | Standort, Fotos, Kamera und mehr ohne Nachfrage erlauben, entziehen oder zurücksetzen |
| send_push | bundle_id, title, body, badge, data, payload | Eine Push-Mitteilung an eine App im Simulator |
| set_appearance | dark, text_size, increase_contrast, reduce_motion | Dunkelmodus, dynamische Schriftgröße und Bedienungshilfen |
| set_language | language, bundle_id | z. B. de-DE, für den Simulator oder eine Android-App |
| set_status_bar | preset, time, battery_level, … | 9:41 Uhr und volle Balken für Screenshots, oder zurücksetzen |
| biometrics | action | Eine Abfrage von Face ID, Touch ID oder Fingerabdruck beantworten |
| reset_app | bundle_id, keychain | Die Daten einer App löschen, als wäre sie gerade installiert |
| clipboard | text | Die Zwischenablage lesen oder setzen |
| set_orientation | orientation | Hoch- oder Querformat |
{"set_permission": {"bundle_id": "com.example.MyApp", "permission": "location"}}
{"set_location": {"latitude": 52.52, "longitude": 13.405}}
{"send_push": {"bundle_id": "com.example.MyApp", "title": "Order shipped", "data": {"order": 7}}}
{"set_status_bar": {"preset": "screenshot"}}Simulatoren und Android
Gestartete iOS-Simulatoren sowie Android-Emulatoren und -Smartphones erscheinen neben deinen iPhones, in der App und in list_devices, und lassen sich mit denselben Tools steuern. Auf ihnen musst du nichts einrichten: kein Kabel, kein Bluetooth, kein Entwicklermodus.
- Der iOS-Simulator braucht Xcode. Mobdev liest den Bildschirm direkt aus dem Simulator und sendet Berührungen und Tastendrücke wie Simulator.app, daher muss kein Fenster offen bleiben. Installiere Builds für den Simulator (
Debug-iphonesimulator); Crash-Reports kommen vom Mac. - Android braucht adb aus dem Android SDK, zum Beispiel über Android Studio. Emulatoren und Smartphones mit USB-Debugging erscheinen, solange adb läuft. Installiert wird eine
.apk,logsfolgt logcat, undpress_keymitescapewirkt als Zurück-Taste. Mobdev zeigt den Bildschirm und sendet Eingaben über den Server von scrcpy, den es mitbringt: Das Video ist schnell, und jeder Text lässt sich tippen, Emoji eingeschlossen.open_appvergleicht mit Paketnamen: „Settings“ öffnet com.android.settings.
xcodebuild -scheme MyApp -destination 'generic/platform=iOS Simulator' \
-derivedDataPath build build
# install_app {"device": "iPhone 17", "path": "…/Debug-iphonesimulator/MyApp.app"}
# install_app {"device": "emulator-5554", "path": "…/app-debug.apk"}Auf beiden listet ui_tree die Elemente auf dem Bildschirm mit Rolle, Label und Accessibility Identifier auf, und tap_element und wait_for_element finden sie über Identifier oder Label: zuverlässiger als die Texterkennung, und sie finden auch Buttons, die nur ein Symbol zeigen. Auf einem iPhone brauchen sie den Entwicklermodus (siehe iPhone einrichten); ohne ihn nutzen Agenten dort tap_text.
Wenn du nur iPhones willst, schalte sie in der App unter „Settings › General“ aus.
Simulatoren und AVDs, die nicht laufen, stehen in der Seitenleiste unter Not Running: ▶ startet einen, ohne Fenster, weil Mobdev den Bildschirm selbst zeigt. New Simulator… legt einen mit jedem Typ und jeder iOS-Version an, die Xcode mitbringt. Agenten machen dasselbe mit diesen Tools, die kein Gerät brauchen. Mobdev löscht nur Simulatoren, die es selbst angelegt hat, und fährt kein Gerät herunter, das ein Flow oder ein Testlauf gerade nutzt.
| Tool | Argumente | Was es tut |
|---|---|---|
| list_virtual_devices | Alle Simulatoren und Android Virtual Devices auf dem Mac, ob sie laufen oder nicht | |
| boot_device | id, window | Einen starten und warten, bis er hochgefahren ist; danach erscheint er in list_devices |
| shutdown_device | id | Einen Simulator herunterfahren oder einen Emulator beenden |
| create_simulator | device_type, runtime, name, boot | Einen iOS-Simulator mit jedem Typ und jeder iOS-Version anlegen, die Xcode mitbringt |
| delete_simulator | id | Einen Simulator löschen, den Mobdev angelegt hat |
Bauen, starten und debuggen
Für Apps, die du selbst entwickelst, installiert Mobdev auch Builds, startet sie und liest ihre Ausgabe und Crash-Reports. Der Agent baut mit xcodebuild, installiert, steuert die App mit den Tools oben und liest die Logs. Diese Tools nutzen devicectl aus Xcode und brauchen deshalb Xcode auf dem Mac und den Entwicklermodus auf dem iPhone (Einstellungen › Datenschutz & Sicherheit › Entwicklermodus). Alles andere funktioniert auch ohne. Simulatoren und Android brauchen beides nicht.
| Tool | Argumente | Was es tut |
|---|---|---|
| list_apps | all | Zur Entwicklung installierte Apps oder alle Apps |
| install_app | path, upload | Einen Build vom Mac installieren oder einen, der über das Relay hochgeladen wurde: .app/.ipa, Simulator-.app oder .apk |
| uninstall_app | bundle_id | Eine zur Entwicklung installierte App entfernen |
| launch_app | bundle_id, arguments, environment, restart | Eine App starten und ihre Ausgabe mitschneiden |
| stop_app | bundle_id | Eine laufende App beenden |
| open_url | url | Einen Deep Link, Universal Link oder eine Webseite öffnen |
| logs | bundle_id, after, lines, contains | Ausgabe von print, NSLog und os_log und wie die App beendet wurde |
| crash_reports | app, name, limit | Crash-Reports auflisten oder einen lesen: Exception, Grund, abgestürzter Thread |
xcodebuild -scheme MyApp -destination 'generic/platform=iOS' \
-derivedDataPath build -allowProvisioningUpdates build
# install_app {"path": "…/build/Build/Products/Debug-iphoneos/MyApp.app"}
# launch_app {"bundle_id": "com.example.MyApp"}
# logs {"bundle_id": "com.example.MyApp"}logs gibt einen Cursor zurück; übergib ihn als after, um nur neue Zeilen zu bekommen. Stürzt die App ab, meldet logs das, und crash_reports zeigt den Crash-Report. Pfade für install_app beziehen sich auf den Mac, auf dem Mobdev läuft, auch über ein Relay. Mobdev entfernt nie Apps aus dem App Store oder System-Apps.
Steuerung im Entwicklermodus. Mobdev Runner wird mit Xcode gebaut, mit deinem Entwicklerteam signiert und auf dem iPhone am Laufen gehalten, so wie WebDriverAgent. Solange er läuft, geht jedes Tippen, Wischen, Zoomen mit zwei Fingern, jede Taste und jeder Text durch ihn, type_text tippt auch Emoji, und ui_tree, tap_element und wait_for_element funktionieren wie in Simulatoren. Für ein einzelnes iPhone schaltest du ihn in dessen Infos in Mobdev aus; dieses iPhone nutzt dann Bluetooth.
Leistung und React Native
performance misst eine laufende App bis zu einer Minute lang, und measure_launch stoppt Kaltstarts so, wie Xcode und Android sie angeben. Auf einem iPhone zeichnet performance den Activity Monitor von Instruments auf, was 10 bis 20 Sekunden länger dauert, und measure_launch misst den Bildschirm, bis er stillsteht. Budgets wie max_ms lassen den Schritt fehlschlagen, so bemerkt ein Test, wenn eine App langsamer oder schwerer geworden ist.
record_trace zeichnet auf iPhones und Simulatoren jede Instruments-Vorlage auf, etwa Time Profiler, Allocations, Leaks, Network, SwiftUI oder App Launch, an eine laufende App angehängt, mit ihrem Start oder für alle Prozesse. Auf Android zeichnet es einen Perfetto-Trace auf. Der Trace landet in output/traces des Projekts, und die Antwort fasst ihn zusammen, wo das wenig kostet: die teuersten Funktionen und Hänger, Ruckler, CPU und Speicher. Öffne ihn in Instruments oder auf ui.perfetto.dev. device_load zeigt das ganze Gerät: die geschäftigsten Prozesse, den Speicher und den Temperaturstatus. Der Geräte-Inspektor in der App hat dasselbe unter „Performance“.
| Tool | Argumente | Was es tut |
|---|---|---|
| performance | bundle_id, seconds, max_cpu, max_memory_mb, max_janky_percent | CPU, Speicher und auf Android Frames einer laufenden App; Budgets lassen den Aufruf fehlschlagen |
| measure_launch | bundle_id, runs, method, max_ms, stable | Kaltstartzeit über mehrere Läufe: schnellster, Median, langsamster |
| record_trace | template, seconds, bundle_id, launch, path | Ein Instruments-Trace (iPhones, Simulatoren) oder ein Perfetto-Trace (Android), mit kurzer Zusammenfassung |
| device_load | count | Das ganze Gerät: die Prozesse mit der meisten CPU und dem meisten Speicher, belegter Speicher, Temperaturstatus |
| reload_app | port | Eine React-Native- oder Expo-App über Metro neu laden, sonst über ihr Entwicklermenü |
| dev_menu | port | Das Entwicklermenü einer React-Native- oder Expo-App öffnen |
{"measure_launch": {"bundle_id": "com.example.MyApp", "runs": 5, "max_ms": 1500}}
{"performance": {"bundle_id": "com.example.MyApp", "seconds": 20, "max_memory_mb": 300}}Netzwerk
Die Netzwerk-Tools zeigen, welche Anfragen eine App stellt: zum Debuggen, um Analytics- und API-Aufrufe zu prüfen und für Datenschutz-Audits. Auf dem Gerät wird nichts installiert, und HTTPS wird nie entschlüsselt. Auf iOS startet Mobdev die App mit Apples Netzwerkdiagnose neu und liest ihr Log: Methode, Host, Status, Bytes und Dauer, Pfade und Queries verbirgt iOS allerdings. Auf Android leitet Mobdev das Gerät über einen Proxy auf dem Mac: einfaches HTTP vollständig, HTTPS als Host, Bytes und Dauer. Endet die Aufzeichnung, verschwindet auch der Proxy wieder, und ein Dev-Server auf dem Mac bleibt unter 10.0.2.2 erreichbar.
| Tool | Argumente | Was es tut |
|---|---|---|
| start_network_capture | bundle_id | Die Anfragen einer App aufzeichnen |
| network_log | bundle_id, contains, after, query, headers | Die aufgezeichneten Anfragen: Methode, URL, Status, Bytes und Dauer |
| stop_network_capture | bundle_id | Die Aufzeichnung beenden; auf Android verschwindet damit auch der Proxy |
| mock_response | url, status, body, content_type, clear | Android: eine feste Antwort auf einfache HTTP-Anfragen, etwa einen Fehler deiner API |
Flows und CI
Ein Flow ist eine Liste von Tool-Aufrufen, gespeichert als JSON. Klicke in der Ansicht „Activity“ eines Geräts auf Record, dann zeichnet Mobdev alle Aktionen auf dem Gerät auf, deine und die eines Agenten; auf Simulatoren, Android und iPhones im Entwicklermodus werden Klicks auf benannte Elemente zu tap_element, sodass der Flow Layoutänderungen übersteht. Abspielen kannst du ihn mit Run Flow…, dem Tool run_flow oder ohne App mit Mobdev flow. Jeder Lauf stoppt beim ersten fehlgeschlagenen Schritt und nennt ihn. Mit „Run Flow…“ entsteht von jedem Lauf ein Video; run_flow speichert eines dort, wo sein Argument video es angibt. Solange ein Flow, ein Testlauf oder ein Crawl läuft, gehört ihm das Gerät: Andere Agenten bekommen „Busy“, bis er endet, damit niemand mitten hineintippt.
{
"name": "Sign in",
"steps": [
{"launch_app": {"bundle_id": "com.example.MyApp", "restart": true}},
{"tap_element": {"id": "email"}},
{"type_text": {"text": "me@example.com", "submit": true}},
{"wait_for_element": {"text": "Welcome"}}
]
}Steuerschritte schauen auf den Bildschirm, statt Wartezeiten zu raten: if führt Schritte aus, wenn etwas zu sehen ist oder auf einer Plattform, repeat wiederholt sie eine bestimmte Zahl von Malen oder bis etwas erscheint, und retry führt sie erneut aus, wenn einer fehlschlägt.
{"if": {"visible": {"text": "Allow"}, "then": [{"tap_element": {"text": "Allow"}}]}}
{"repeat": {"until_visible": {"id": "checkout"}, "max": 10, "steps": [{"scroll": {"direction": "down"}}]}}
{"retry": {"times": 2, "steps": [{"tap_element": {"id": "pay"}}, {"wait_for_text": {"text": "Paid"}}]}}Flows von Maestro laufen unverändert: run_flow, Mobdev flow und Tests nehmen .yaml-Dateien, und Mobdev convert wandelt einen Flow ins jeweils andere Format um.
Mobdev convert login.yaml > login.json # Maestro to Mobdev
Mobdev convert login.json > login.yaml # Mobdev to MaestroMobdev flow läuft auf gestarteten Simulatoren und Android-Geräten, für Skripte und CI. Es endet mit Exit-Code 0, wenn alle Schritte erfolgreich waren, und mit 1, wenn einer fehlgeschlagen ist; --artifacts sichert ein Video des Laufs (run.mp4), das Aktivitätsprotokoll, Crash-Reports und einen Screenshot des Fehlers. Nutze in CI lieber tap_element als die Tools mit Texterkennung, denn die funktionieren auf den virtualisierten Macs von GitHub nicht.
/Applications/Mobdev.app/Contents/MacOS/Mobdev flow sign-in.json \
--device "$UDID" --artifacts flow-artifactsAuf GitHub erledigt die Mobdev-Action all das auf einem gehosteten Mac: Sie startet einen Simulator, installiert deinen Build, führt ein Testprojekt oder einen Flow aus, schreibt die Ergebnisse in die Job-Zusammenfassung und auf Wunsch in einen Kommentar zum Pull Request und bewahrt Videos und Screenshots als Artefakt auf.
- uses: niklas-schmidt-dev/mobdev/actions/test@main
with:
project: mobdev
comment: trueProjekte
Ein Projekt ist ein Ordner im Repository deiner App, meist mobdev/, mit allem, was Mobdev für die App aufbewahrt. Committe alles außer output/: Dieser Ordner bringt seine eigene .gitignore mit und entsteht erst, wenn Mobdev zum ersten Mal etwas hineinschreibt.
mobdev/
mobdev.json the app, its builds and what every test starts with
tests/ tests
flows/ saved flows
baselines/ assert_screenshot's reference pictures
screenshots/ save_screenshot's pictures, such as store screenshots
maps/ crawl_app's map of each app
output/ test runs, recordings, crawls, failed checks and flow videos- New Project… in der App schreibt
mobdev/mobdev.jsonin das Repository, das du auswählst, mit der Bundle ID, die es dort in einer Expo-Konfiguration, im Xcode-Projekt oder in Gradle findet, und Open Project… fügt ein vorhandenes hinzu. Projekte stehen oben in der Seitenleiste, jedes mit seinen Tests, Flows, Screenshots, App-Karte, Aufnahmen und Läufen. - Das Projekt, das du auswählst, ist das aktive: Aufnahmen, Screenshots, gespeicherte Flows und Tests, Crawls und benannte Referenzbilder landen ohne Pfad dort.
- Der Arbeitsordner eines Agenten geht vor:
Mobdev mcpschickt das Projekt des Ordners, in dem es läuft. So speichern Agenten in zwei Repositorys, oder in zwei Worktrees eines Repositorys, nie in das Projekt des anderen. Agenten finden Projekte mitlist_projectsund wechseln mitopen_project. - Die Übersicht eines neuen Projekts sagt, was als Nächstes kommt: deinen Agenten verbinden, ihn die ersten Tests schreiben lassen, sie ausführen und in CI laufen lassen, mit Prompts zum Kopieren, die für jede Aufgabe den passenden Skill nennen.
- Ein Testlauf bleibt in seinem Projekt, auch wenn währenddessen ein anderes aktiv wird.
- Jedes Projekt zeigt das Icon seiner App, gefunden im Repository: das Icon aus einer Expo-
app.json, das iOS-App-Icon oder das Launcher-Icon von Android. In der Übersicht des Projekts wählst du jede andere Bilddatei.
Tests
Die Tests eines Projekts sind Dateien in seinem Ordner tests/, und mobdev.json nennt die App, ihre Builds je Plattform und die Schritte, mit denen jeder Test beginnt. Jede Datei ist ein Test: ein Flow mit Name, Beschreibung und den Plattformen, auf denen er läuft. Ein Test besteht, wenn jeder Schritt besteht, darum endet er mit einem Warten, das das Ergebnis belegt. ${NAME} nimmt eine Variable aus dem Projekt, der Umgebung oder dem Lauf. Der Wert eines Secrets kommt aus dem Lauf, der Umgebung oder einem Secret, das unter „Settings › Secrets“ gespeichert ist, und taucht nie in Ergebnissen auf.
{
"name": "My App",
"app": {"bundle_id": "com.example.MyApp", "builds": {"simulator": "build/MyApp.app"}},
"before_each": [{"launch_app": {"bundle_id": "com.example.MyApp", "restart": true}}],
"variables": {"EMAIL": "me@example.com"},
"secrets": ["PASSWORD"]
}Tests eines Projekts in der App führt sie auf einem Gerät aus und zeigt jedes Ergebnis mit seinen Schritten, dem Screenshot eines Fehlschlags und dem Video. Agenten bekommen dasselbe über list_tests, save_test, run_tests und test_result: Sie fahren die App, bis ein Pfad funktioniert, speichern ihn als Test, führen ihn aus und reparieren ihn ab dem fehlgeschlagenen Schritt. Mobdev test führt ein Projekt in CI ohne die App aus und schreibt results.json, junit.xml sowie ein Video und einen Screenshot je Test.
/Applications/Mobdev.app/Contents/MacOS/Mobdev test mobdev/ \
--device "$UDID" --artifacts test-artifactsWiederhole --device, um auf mehreren Geräten gleichzeitig zu testen, oder ergänze --simulator "iPhone 17", damit für den Lauf ein Simulator dieses Typs angelegt und danach wieder gelöscht wird. --emulator Pixel_9_Pro startet dieses Android Virtual Device schreibgeschützt für den Lauf, auch mehrere Kopien gleichzeitig, und beendet es danach wieder. --language de-DE führt die Tests in dieser Sprache aus, wiederholt in jeder Sprache nacheinander, und stellt danach die alte wieder ein. Jedes Gerät und jede Sprache bekommt einen eigenen Ordner, und summary.md passt direkt in eine CI-Job-Zusammenfassung. Ein Testschritt wie {"save_screenshot": {"path": "${LANGUAGE}/01-home"}} speichert Store-Screenshots in jeder Sprache. Hat ein Agent einen Weg durch die App gefunden, gibt ihm recent_steps die Aktionen, die geklappt haben, zum Speichern mit save_test.
Native Tests
run_native_tests führt die eigene XCTest-, XCUITest-, Swift-Testing- oder Gradle-Suite der App auf dem gewählten Gerät aus: xcodebuild test auf einem Simulator oder einem iPhone im Entwicklermodus, connectedDebugAndroidTest auf einem Emulator oder Telefon und testDebugUnitTest auf dem Mac. Mobdev findet Workspace, Scheme und gradlew im Repository oder liest sie aus native_tests in mobdev.json. Jeder Fehlschlag kommt mit Meldung, Datei und Zeile zurück, fehlgeschlagene UI-Tests mit ihrer Bildschirmaufnahme. Lange Läufe gehen im Hintergrund weiter, damit Agenten und Relays nicht abgeschnitten werden; native_test_result liest sie. Jeder Lauf behält junit.xml und das Result-Bundle, und die App zeigt sie unter Tests › Native Tests.
"native_tests": {
"ios": {"workspace": "MyApp.xcworkspace", "scheme": "MyApp", "test_plan": "CI"},
"android": {"gradle_root": "android", "task": "connectedDebugAndroidTest"}
}
Mobdev test mobdev/ --native --simulator "iPhone 17" --artifacts native-artifactsPrüfungen
Drei Tools beurteilen den Bildschirm und lassen ihren Schritt fehlschlagen, wenn er nicht besteht. So prüft ein Test, wie ein Bildschirm aussieht, nicht nur, was darauf steht.
{"assert_screenshot": {"name": "home", "mask": ["home.clock"]}}
{"accessibility_audit": {"fail_on": "error"}}
{"assert_with_ai": {"question": "Is any text cut off?", "expect": "no"}}assert_screenshotvergleicht den Bildschirm mit einem Referenzbild. Der erste Lauf nimmt es im Ordnerbaselinesdes Projekts auf; committe ihn mit deinen Tests. Bei einem Fehlschlag bleibt ein Differenzbild mit markierten Änderungen, im Lauf oder inoutput/des Projekts. Die Statusleiste wird ausgelassen, undmasklässt mehr aus, etwa eine Uhr oder eine Karte.accessibility_auditfindet Tasten ohne Beschriftung, Tippflächen, die kleiner sind, als iOS und Android empfehlen, Text unter den Kontrastwerten der WCAG und Beschriftungen, die wie Dateinamen oder Kennungen klingen.assert_with_aistellt Apple Intelligence auf dem Mac eine Ja/Nein-Frage zum Bildschirm. Der Screenshot bleibt auf dem Mac, auf dem Apple Intelligence eingeschaltet sein muss.
Eine App erkunden
crawl_app erkundet eine App selbstständig, ohne Modell: Es startet die App, tippt jedes Element an, das es noch nicht probiert hat, erfasst die Bildschirme mit Screenshots und hält jeden Absturz mit den Schritten fest, die ihn auslösen, als Flow zum Abspielen. Textfelder tippt es nie an, ebenso wenig alles, was nach Löschen, Bezahlen, Kaufen, Senden oder Abmelden klingt. Die Karte kommt in den Ordner maps/ des Projekts, die Screenshots in seinen Ordner output/. navigate_to geht danach direkt zu einem erfassten Bildschirm, über seinen Titel.
{"crawl_app": {"bundle_id": "com.example.MyApp", "max_actions": 60}}
{"navigate_to": {"bundle_id": "com.example.MyApp", "screen": "Settings"}}App Store Connect
Mit einem API-Schlüssel für App Store Connect listet Mobdev deine Apps in der Seitenleiste auf, mit ihren Builds, TestFlight-Gruppen, App-Store-Versionen und Kundenbewertungen, und Agenten lesen dasselbe mit den appstore_-Tools. Sie brauchen kein Gerät. app ist eine Bundle-ID oder App-ID; ohne sie nimmt Mobdev die des aktiven Projekts.
- Öffne in App Store Connect Benutzer und Zugriff › Integrationen › App Store Connect API und erstelle einen Teamschlüssel mit der Rolle App-Manager.
- Lade seine .p8-Datei herunter, die Apple nur einmal anbietet, und kopiere die Aussteller-ID über der Liste der Schlüssel.
- Öffne in Mobdev Settings › App Store Connect, trage die Aussteller-ID ein, wähle die .p8-Datei und klicke auf „Save Key“.
Der Schlüssel bleibt auf deinem Mac und ist nur für dich lesbar. Kein Tool gibt ihn heraus, und er geht nie über ein Relay; Mobdev signiert damit kurzlebige Tokens und spricht nur mit Apples API. Einen Build einer TestFlight-Gruppe geben, „What to Test“ setzen und auf Bewertungen antworten ändert, was Tester und Kunden sehen: Agenten dürfen das erst, wenn du in denselben Einstellungen Agents may change App Store Connect einschaltest, und in der App fragt jede Änderung vorher nach.
| Tool | Argumente | Was es tut |
|---|---|---|
| appstore_apps | Die Apps des Schlüssels: Name, Bundle-ID, App-ID | |
| appstore_builds | app, version, limit | Builds, neueste zuerst, mit Verarbeitungs- und TestFlight-Status |
| appstore_testflight | app | TestFlight-Gruppen mit Anzahl der Tester, öffentlichem Link und Builds |
| appstore_versions | app, limit | App-Store-Versionen und ihr Prüfstatus |
| appstore_reviews | app, rating, territory, unanswered, limit | Kundenbewertungen und deine Antworten |
| appstore_add_build_to_group | app, build, version, group | Einer TestFlight-Gruppe einen Build geben |
| appstore_set_what_to_test | app, build, version, text, locale | „What to Test“ eines Builds setzen |
| appstore_reply_to_review | review, text | Auf eine Kundenbewertung antworten oder deine Antwort ersetzen |
Skills
Skills geben deinem Agenten ganze Arbeitsabläufe auf Basis der Tools: den Kreislauf aus Bauen und Debuggen, Smoke-Tests, das Nachstellen gemeldeter Fehler, Screenshots für den App Store und Google Play, React-Native- und Expo-Apps, Onboarding-Audits und Konkurrenzanalysen. Sie funktionieren mit Claude Code, Codex, Cursor und anderen Agenten, die SKILL.md-Dateien lesen.
npx skills add niklas-schmidt-dev/mobdevOder kopiere einen Ordner aus skills/ in das Skills-Verzeichnis deines Agenten.
Fernzugriff
Damit du deine Geräte von einem anderen Computer aus erreichst, hält der Mac eine ausgehende WebSocket-Verbindung zu einem Relay. Auf dem Mac wird kein Port geöffnet, und das Relay speichert nichts.
- Melde dich im Dashboard an und erstelle ein Zugangstoken.
- Klicke auf „In Mobdev öffnen“ oder füge das Token in der App unter „Remote Access“ ein.
- Kopiere den Remote-Befehl aus der App und führe ihn auf dem anderen Computer aus:
claude mcp add --transport http mobdev-remote \
https://relay.mobdev.sh/h/<mac-name>/mcp \
--header "Authorization: Bearer mdc_…"Der Client-Schlüssel (mdc_…) wird aus einem Geheimnis abgeleitet, das deinen Mac nie verlässt. Wer ihn hat, kann deine Geräte steuern; „New Client Key“ in der App widerruft ihn. Widerrufst du das Zugangstoken im Dashboard, wird der Mac getrennt.
Builds von überall
Ein Cloud-Agent oder ein CI-Job baut die App in seinem eigenen Container, lädt den Build über das Relay auf den Mac hoch und installiert ihn dort mit install_app und der ID des Uploads. Das Relay behält nichts; der Mac löscht den Build einen Tag nach seiner letzten Verwendung. Das Skript braucht nur eine Shell und curl; auf einem Mac erledigt Mobdev upload dasselbe.
curl -fsSLO https://raw.githubusercontent.com/niklas-schmidt-dev/mobdev/main/scripts/mobdev-upload.sh
export MOBDEV_URL=https://relay.mobdev.sh/h/<mac-name> MOBDEV_KEY=mdc_…
id=$(sh mobdev-upload.sh app-debug.apk)
# install_app {"upload": "<id>", "device": "emulator-5554"}Live-Ansicht
Schalte in der App unter „Remote Access“ „Allow live view“ ein und klicke dann im Dashboard neben einem Gerät auf „Live“, um seinen Bildschirm im Browser zu sehen: Klicke zum Tippen, ziehe zum Wischen und schreibe darauf. „Teilen …“ erstellt dort einen Link, der abläuft, zum Ansehen oder zum Steuern, den jeder ohne Konto öffnen kann, bis du ihn widerrufst. Die App zeigt, wenn jemand zusieht, und kann es beenden. Zusehen zählt als aktive Zeit. Agenten öffnen denselben Stream mit dem Client-Key unter /v1/live; siehe das Protokoll des Relays.
Limits des gehosteten Relays
Der Tarif Free verbindet 1 Mac und enthält 20.000 Anfragen und 10 aktive Stunden pro Monat. Der Tarif Pro (9 US-Dollar pro Monat zzgl. anfallender Steuern) verbindet 3 Macs und enthält 1.000.000 Anfragen und 300 aktive Stunden pro Monat. Aktive Zeit zählt, während ein Mac an einer Anfrage arbeitet; ein verbundener Mac, der wartet, kostet nichts. Das Dashboard zeigt, was du verbraucht hast. Mobdev auf dem Mac und ein selbst gehostetes Relay haben keine Limits.
Ist ein Limit erreicht, antwortet das Relay mit HTTP 429 und einem Retry-After-Header:
- Mehr als 50 Anfragen in 10 Sekunden mit einem Client-Schlüssel.
- Mehr als 4 Anfragen warten auf denselben Mac.
- Die Anfragen oder die aktive Zeit des Monats sind aufgebraucht. Retry-After nennt den Zeitpunkt, an dem sie sich erneuern.
Eigenes Relay betreiben
Das Relay im Repository spricht dasselbe Protokoll. Es ist ein einzelnes Go-Binary oder ein kleines Docker-Image:
cd relay
RELAY_HOST_ACCESS_TOKEN=choose-one go run .
# or
docker build -t mobdev-relay . && docker run -p 8080:8080 mobdev-relayBetreibe es hinter HTTPS und trage seine URL in der App ein. Ist RELAY_HOST_ACCESS_TOKEN gesetzt, dürfen sich nur Macs verbinden, die das Token kennen.
Sicherheit und Datenschutz
- Die lokale API lauscht nur auf 127.0.0.1, verlangt ein Bearer-Token und lehnt Anfragen aus dem Browser ab.
- Die Texterkennung läuft auf dem Mac. Kein Bildschirminhalt verlässt ihn, außer dein Agent schickt ihn an sein Modell.
- Das gehostete Relay speichert deine E-Mail-Adresse, gehashte Zugangstokens, welche Macs verbunden sind und die iPhones, die sie melden. Anfragen und Screenshots laufen nur durch den Arbeitsspeicher. Mehr dazu unter Datenschutz.
- Agenten handeln auf deinem echten Smartphone mit deinen Konten. Lass bei allem, was Nachrichten sendet, bezahlt oder löscht, einen Menschen mitentscheiden.
- Unter „Settings › Agents“ trägst du Apps ein, die Agenten nie öffnen dürfen, etwa deine Bank. Das verhindert Versehen; eine Sandbox ist es nicht.
- Secrets, die Agenten tippen, liegen in einer Datei, die nur du lesen kannst. Agenten sehen ihre Namen, nie ihre Werte, und über ein Relay nur die, die du freigibst.