Claude Code remote vom Telefon steuern

Claude Code ist ein terminalbasierter KI-Coding-Assistent. Er läuft auf Ihrem Mac, liest Ihre Codebasis, schreibt Code, führt Tests aus und committet Änderungen. Das Problem: Sie müssen am Mac sitzen, während er arbeitet.

Tactic Remote löst diese Einschränkung. Ihr Mac bleibt die Ausführungsmaschine. Ihr iPhone wird die Steuerfläche. Dieser Artikel beschreibt genau, wie das funktioniert — Architektur, Protokoll, Kompromisse und Einrichtung. Ohne Handwedeln.

Kurzfassung: Ein Node.js WebSocket-Server auf Ihrem Mac verwaltet Claude Code über tmux. Ihr iPhone verbindet sich per LAN oder Cloudflare Tunnel, sendet Befehle und empfängt gestreamte Terminal-Ausgaben. Push-Benachrichtigungen informieren Sie, wenn Claude fertig ist oder Input braucht.

Die Architektur

Vier Komponenten, drei Netzwerkpfade:

┌──────────────────────────────────────────────────────────┐
│                       Your Mac                           │
│                                                          │
│  ┌─────────────┐    WebSocket     ┌──────────────────┐   │
│  │  Node.js    │◄───(ws://)──────►│   tmux session   │   │
│  │  server     │    send-keys     │                  │   │
│  │  (port 8765)│    capture-pane  │  $ claude        │   │
│  └──────┬──────┘                  │  > Working on... │   │
│         │                         └──────────────────┘   │
│         │ HTTP POST /hook                                │
│         │ (Claude Code hooks)                            │
└─────────┼────────────────────────────────────────────────┘
          │
          │ ws:// (LAN) or wss:// (Cloudflare Tunnel)
          │
┌─────────┼─────────────────────────────┐
│  Your iPhone                          │
│         │                             │
│  ┌──────▼──────┐   ┌──────────────┐   │
│  │  WebSocket  │──►│  ANSI Parser │   │
│  │  Client     │   │  + Terminal  │   │
│  │             │◄──│    Buffer    │   │
│  └─────────────┘   └──────────────┘   │
│                                       │
│  Push notification when Claude        │
│  completes or needs input             │
└───────────────────────────────────────┘

Der Node.js-Server hat genau eine Laufzeitabhängigkeit: das ws npm-Paket. Alles andere — HTTP-Server, Authentifizierung, Rate Limiting, tmux-Verwaltung, Datei-Browsing — basiert auf Node.js-Built-ins. Das ist Absicht. Weniger Abhängigkeiten bedeutet weniger Dinge, die kaputtgehen, weniger Supply-Chain-Risiken und eine kleinere Angriffsfläche.

Wie der Server Claude Code steuert

Hier ist der Teil, der die meisten überrascht: Es gibt keine API zwischen Server und Claude Code. Der Server steuert Claude Code genauso wie Sie — durch Tippen in ein Terminal.

Claude Code läuft in einer tmux-Session. Der Server sendet Tastatureingaben mit tmux send-keys und liest die Ausgabe mit tmux capture-pane. Es ist Terminal-Automatisierung, keine SDK-Integration.

Eine Session erstellen

Wenn Sie eine neue Session von Ihrem iPhone erstellen:

# 1. Create a detached tmux session in your project directory
tmux new-session -d -s my-project -c /Users/you/code/my-project
 
# 2. Set a large scrollback buffer (default is 2000, we use 50,000)
tmux set-option -t my-project history-limit 50000
 
# 3. Type "claude" into the session
tmux send-keys -t my-project -l 'claude'
 
# 4. Press Enter
tmux send-keys -t my-project C-m

Das -l-Flag bei send-keys ist entscheidend — es weist tmux an, den Inhalt wörtlich zu interpretieren und verhindert, dass Sonderzeichen als tmux-Tastennamen behandelt werden.

Der 50.000-Zeilen-Scrollback-Buffer ist das 25-fache des tmux-Standards. Claude Code-Sessions produzieren enorme Ausgaben — Kompilierungslogs, Datei-Diffs, Testsuiten. Ohne das würden Sie nach wenigen Minuten intensiver Arbeit den Kontext verlieren.

Eine Nachricht an Claude senden

Wenn Sie auf dem iPhone einen Prompt eingeben und absenden:

# Clear any existing input
tmux send-keys -t my-project C-u
 
# Type the content literally
tmux send-keys -t my-project -l 'refactor the auth module to use JWT'
 
# Press Enter
tmux send-keys -t my-project C-m

Das C-u am Anfang löscht die Eingabezeile. Ohne das würde Ihre Nachricht an eventuell vorhandenen Text angehängt, falls Claude teilweisen Text im Prompt hinterlassen hat.

Claude stoppen

Stoppen ist eine mehrstufige Sequenz, weil Claude Code zwei Zustände hat, die unterschiedlich gehandhabt werden müssen:

# Interrupt if Claude is processing
tmux send-keys -t my-project C-c
sleep 0.2
 
# Interrupt again (double Ctrl+C for stubborn processes)
tmux send-keys -t my-project C-c
sleep 0.2
 
# Send the quit command
tmux send-keys -t my-project -l '/exit'
tmux send-keys -t my-project C-m

Wenn Claude gerade verarbeitet, unterbricht Ctrl+C es. Wenn Claude bereits am Prompt ist, ist /exit der Beenden-Befehl von Claude Code. Beides zu senden, deckt beide Zustände ab. Die 200ms-Pausen geben Claude Zeit, jedes Signal zu verarbeiten.

Terminal-Ausgabe-Streaming

Das ist das schwierigste Engineering-Problem im gesamten System. Claude Code gibt bei Kompilierung oder Testläufen hunderte Zeilen pro Sekunde aus. Diese Ausgabe muss Ihr iPhone in Echtzeit erreichen, ohne den Akku zu leeren oder das Netzwerk zu überlasten.

Die Polling-Schleife

Der Server erfasst Terminal-Inhalte mit einem 1-Sekunden-Polling-Intervall:

tmux capture-pane -t my-project -p -S -2000

Das holt die letzten 2.000 Zeilen Scrollback als Klartext mit erhaltenen ANSI-Escape-Codes.

Warum Polling statt Event-basiert? tmux bietet keine Änderungsbenachrichtigungen. Wir haben Filesystem-Watcher auf tmux' internem Socket evaluiert — fragil über macOS-Versionen hinweg. Polling mit 1 Sekunde ist eine gute Balance: schnell genug, damit die Ausgabe in Echtzeit wirkt, langsam genug, um CPU-Nutzung bei inaktiver Session zu minimieren.

Stabilitätserkennung

Der Ausgabe-Monitor streamt nicht einfach rohe Captures. Er führt einen Stabilitätserkennungsalgorithmus aus:

1. Terminal-Inhalt jede Sekunde erfassen
2. Mit dem vorherigen Capture vergleichen
3. Wenn unterschiedlich: Update an das iPhone senden, Stabilitätszähler zurücksetzen
4. Wenn identisch für 5 aufeinanderfolgende Captures (5 Sekunden stabil): prüfen, ob Claude auf Input wartet
5. Wenn Claude am Prompt ist: finales Update mit final: true senden, dann Polling stoppen

Das behandelt Claudes progressive Darstellung — bei langen Ausgaben ändert sich das Terminal schnell. Nachdem Claude fertig ist, stabilisiert sich der Bildschirm. Fünf Sekunden Stabilität sind ein zuverlässiges Signal, dass Claude fertig ist.

Der Monitor hat ein hartes Limit von 120 Prüfungen (2 Minuten). Wenn die Ausgabe nach 2 Minuten noch wechselt, stoppt der Monitor und der Client kann eine manuelle Aktualisierung anfordern.

Wie wir Claudes Zustand erkennen

Der Server liest Claudes TUI per Screen-Scraping, um festzustellen, was es tut. Das ist notwendigerweise heuristisch:

const claudeIndicators = [
  '> ', // Input prompt
  '│ >', // Input prompt inside border
  '? for shortcuts', // Help text visible at prompt
  '╭─', // Claude UI top border
  '╰─', // Claude UI bottom border
  '●', // Running indicator
]

Wir prüfen die letzten Zeilen der Terminal-Ausgabe auf diese Muster. Wenn wir Goodbye! oder Session ended sehen, hat Claude sich beendet. Wenn wir einen Shell-Prompt ($ am Zeilenende) ohne Claude-spezifische Indikatoren sehen, ist die Session zur Shell zurückgekehrt.

Ist das fragil? Etwas. Wenn Claude Code sein TUI-Layout ändert, brechen unsere Heuristiken. Aber die Alternative — einen eigenen IPC-Kanal in Claude Code einzubauen — würde das Pflegen eines Forks und das Verfolgen von Upstream-Änderungen erfordern. Screen-Scraping des bestehenden TUI ist pragmatisch: Es funktioniert mit jeder Version von Claude Code ohne Modifikation.

ANSI-Farberhaltung

Eine wichtige Design-Entscheidung: Der Server behält ANSI-Escape-Codes in der Ausgabe bei. Er entfernt problematische Terminal-Sequenzen (Cursorbewegung, OSC-Titel-Sequenzen, Private-Mode-Änderungen), behält aber bewusst Farbcodes bei:

// These are stripped (cause rendering problems):
cleaned = cleaned
  .replace(/\x1b\].*?\x07/g, '') // OSC sequences
  .replace(/\x1b\[\?[0-9;]*[a-z]/g, '') // Private mode
  .replace(/\x1b\[[0-9;]*[ABCDEFGJKST]/g, '') // Cursor movement
 
// SGR color codes (\x1b[...m) are NOT stripped

Die iOS-App parst diese Codes dann zu nativen AttributedString-Stilen. So erhalten Sie Claude Codes vollständige Farbausgabe — Syntax-Highlighting, Diff-Farben, Status-Indikatoren — originalgetreu auf Ihrem Telefonbildschirm gerendert. Der Parser unterstützt Standard-16-Farben, 256-Farb-Modus und 24-bit True Color.

Das WebSocket-Protokoll

Der Server spricht zwei Protokolle gleichzeitig auf derselben WebSocket-Verbindung — ein Legacy-Flat-Protokoll und ein neueres Request/Response/Event-Protokoll.

Neues Protokoll (Empfohlen)

Drei Frame-Typen:

// Client → Server: Request
{
  "type": "req",
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "method": "send_to_claude",
  "params": { "content": "fix the failing tests", "session": "my-project" }
}
 
// Server → Client: Response
{
  "type": "res",
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "ok": true,
  "payload": { "status": "sent" }
}
 
// Server → Client: Event (no request ID)
{
  "type": "event",
  "event": "hook_event",
  "payload": { "event": "Stop", "project": "my-project" }
}

Das id-Feld ermöglicht korrektes asynchrones Request-Multiplexing. Der Client kann mehrere laufende Requests haben und Antworten korrekt zuordnen. Das Legacy-Protokoll hat keine Request-IDs — Antworten sind positionell, und bei zwei schnell aufeinanderfolgenden Requests kann man nicht unterscheiden, welche Antwort zu welchem Request gehört.

Vollständiger Methodenkatalog

Die send_key-Methode hat eine explizite Allowlist von 18 Tasten. Sie können keine beliebigen Tastensequenzen senden — nur Tasten, die für die Interaktion mit Claude Codes Interface sinnvoll sind. Die y- und n-Tasten sind speziell enthalten, um Claudes Berechtigungsabfragen vom Telefon zu beantworten.

Netzwerk: LAN vs. Cloudflare Tunnel

Zwei Verbindungsmodi lösen zwei verschiedene Probleme.

Lokales Netzwerk (LAN)

Ihr iPhone verbindet sich direkt mit Ihrem Mac über WiFi:

iPhone ──── ws://192.168.1.50:8765 ──── Mac

Die Mac-Companion-App veröffentlicht einen Bonjour-Service (_ws._tcp.), damit Ihr iPhone ihn im Netzwerk automatisch entdeckt. Keine Konfiguration nötig — App öffnen, Banner tippen, verbunden.

Latenz: Unter 10ms Round-Trip. Terminal-Streaming fühlt sich sofort an.

Einschränkung: Funktioniert nur im selben Netzwerk. Sobald Sie das Haus verlassen, verlieren Sie die Verbindung.

Cloudflare Tunnel

Für Remote-Zugriff kann die Mac-Companion-App einen Cloudflare Tunnel starten:

iPhone ── wss://xxx.trycloudflare.com ── Cloudflare Edge ── Mac

Der Tunnel ist nur ausgehend von Ihrem Mac. Keine Ports werden an Ihrer Firewall geöffnet. Keine Router-Konfiguration. Cloudflare übernimmt TLS-Terminierung, DDoS-Schutz und WebSocket-Proxying.

Quick-Tunnel-Setup generiert eine zufällige *.trycloudflare.com-Subdomain und einen zufälligen 32-Zeichen-API-Schlüssel:

# Auto-generated from: openssl rand -hex 16
export CLAUDE_REMOTE_API_KEY="a3f8b2c1d4e5f6a7b8c9d0e1f2a3b4c5"
 
cloudflared tunnel --url http://localhost:8765
# Your quick Tunnel has been created!
# https://abc123-random-words.trycloudflare.com

Kein Cloudflare-Konto nötig. Kostenlos. Funktioniert in etwa 10 Sekunden.

Latenz: 30–80ms typisch, abhängig von Ihrer Entfernung zur nächsten Cloudflare-Edge.

Kompromiss: Die URL ändert sich bei jedem Tunnel-Neustart. Für eine persistente URL brauchen Sie ein Cloudflare-Konto und einen Named Tunnel (weiterhin kostenlos).

QR-Code-Schnellverbindung

Die Verbindung manuell einzurichten bedeutet, eine IP-Adresse, Port und API-Schlüssel auf einer Telefontastatur einzugeben. Das ist fehleranfällig und nervig.

Die Mac-Companion-App generiert einen QR-Code mit den Verbindungsdetails als JSON:

{
  "ip": "192.168.1.50",
  "port": 8765,
  "apiKey": "a3f8b2c1d4e5f6a7b8c9d0e1f2a3b4c5",
  "mode": "lan",
  "version": "1.0"
}

Scannen Sie ihn aus der iPhone-App mit dem Vision-Framework-Barcode-Detektor. Ein Scan richtet die gesamte Verbindung ein — Modus, Adresse, Authentifizierung. Dauert etwa 3 Sekunden.

Benachrichtigungs-Pipeline

Push-Benachrichtigungen sind TacticRemotes Killer-Feature für „Einstellen und vergessen"-Workflows. Starten Sie eine lange Aufgabe, gehen Sie weg, werden Sie benachrichtigt, wenn Claude fertig ist oder Ihren Input braucht.

Wie es funktioniert

Claude Code unterstützt Hooks — Shell-Skripte, die bei Lifecycle-Events ausgeführt werden. Die Mac-Companion-App konfiguriert diese Hooks automatisch, um an den lokalen Server zu POSTen:

#!/bin/bash
# ~/.claude/hooks/stop.sh (auto-configured)
curl -s -X POST http://localhost:8765/hook \
  -H "Content-Type: application/json" \
  -d "{\"event\": \"Stop\", \"project\": \"$CLAUDE_PROJECT\", \"tmux_session\": \"$TMUX_SESSION\"}"

Wenn Claude eine Aufgabe abschließt, wird dieser Hook ausgelöst. Der Server empfängt den POST, sendet ein Benachrichtigungs-Event an alle verbundenen Clients, und die iOS-App löst eine lokale Benachrichtigung über UNNotificationCenter aus.

Event-Deduplizierung

Hook-Events können in schneller Folge ausgelöst werden (z.B. wenn Claude mehrere Unteraufgaben nacheinander abschließt). Die iOS-App dedupliziert Events mit einem 3-Sekunden-Fenster, geschlüsselt nach event|project|session|timestamp. Wenn dasselbe logische Event innerhalb von 3 Sekunden zweimal eintrifft, wird das Duplikat still verworfen.

Vordergrund vs. Hintergrund

Wenn die App im Vordergrund ist, hängen Benachrichtigungs-Events einen visuellen Indikator an den Terminal-Buffer an:

📢 [Claude] Project completed

Wenn die App im Hintergrund ist, wird eine System-Benachrichtigung ausgelöst. Tippen Sie darauf, um direkt in Ihre Session zurückzukehren.

Sicherheitsmodell

KI-generierten Code remote auszuführen erfordert ein ernsthaftes Sicherheitsmodell. Hier ist unseres.

Authentifizierung

Der Server unterstützt API-Schlüssel-Authentifizierung über zwei Mechanismen:

• Authorization: Bearer <key> Header (Standard)
• Sec-WebSocket-Protocol: <key> Header (Fallback für iOS-WebSocket-Bibliotheken, die keine benutzerdefinierten Header beim Upgrade-Request setzen können — eine gängige mobile Einschränkung)

Die Authentifizierung wird einmal beim Verbindungsaufbau geprüft. Bei Fehlschlag wird der WebSocket sofort mit Code 1008 (Policy Violation) geschlossen.

Schutz vor Command Injection

Jeder externe Befehl, den der Server ausführt, geht durch execSafe(), das child_process.spawn() mit shell: false aufruft. Argumente werden als Arrays übergeben, nie in Strings interpoliert. Shell-Injection ist strukturell unmöglich.

Input-Validierung bietet zusätzliche Verteidigungstiefe:

Pfad-Traversal-Schutz

Datei-Browsing ist auf den Home-Verzeichnisbaum beschränkt. Sensible Verzeichnisse sind unabhängig von anderen Einstellungen immer blockiert:

const SENSITIVE_DIRS = [
  '.ssh',
  '.gnupg',
  '.aws',
  '.kube',
  '.config/gcloud',
  'Library/Keychains',
  'Library/Cookies',
  'Library/Application Support/1Password',
]

Die Prüfung verwendet Segment-für-Segment-Matching (nicht Substring-Matching), sodass ein Verzeichnis namens my-.ssh-backup keinen Fehlalarm auslöst.

Rate Limiting

Fehlgeschlagene Authentifizierungsversuche werden auf 30 pro Minute pro IP begrenzt, mittels eines In-Memory-Sliding-Window. Nach Überschreitung gibt der Server 429 Too Many Requests mit einem retryAfter-Hinweis zurück.

Keine Cloud-Abhängigkeit

Ihr Code verlässt nie Ihren Mac. Tactic Remote ist eine Steuerebene, keine Datenebene. Der WebSocket überträgt Terminal-Text — Befehlseingaben und Ausgabe-Strings. Quelldateien, Git-History und Build-Artefakte bleiben auf Ihrem Rechner.

Bei Nutzung von Cloudflare Tunnel verschlüsselt der Tunnel den Datenverkehr Ende-zu-Ende. Cloudflare sieht verschlüsselte WebSocket-Frames, nicht Ihren Code.

Die iOS-App: Kein Terminal-Emulator

Früh in der Entwicklung trafen wir eine bewusste Entscheidung: Die iPhone-App ist kein einfacher Terminal-Emulator. Ein vollständiges 80x24-Terminal auf einen 4-Zoll-Telefonbildschirm zu quetschen, ist eine schreckliche Erfahrung.

Stattdessen bietet die App:

• Konversationsartiger Input: Nachrichten an Claude in einem Textfeld eingeben, nicht an einem Terminal-Prompt
• Terminal-Ausgabe-View: Gerenderter Text mit ANSI-Farbunterstützung, Auto-Scrolling, Pinch-to-Zoom-Schriftgröße (Standard 8pt)
• Schnellaktions-Buttons: Enter, Escape, Tab, Y, N, Ctrl+C — die Tasten, die Sie bei der Interaktion mit Claude Code tatsächlich brauchen
• Session-Picker: tmux-Sessions durchsuchen und wechseln
• Pfad-Browser: Dateisystem Ihres Mac navigieren, um das Arbeitsverzeichnis festzulegen
• Slash-Commands: Auto-Vervollständigung für /help, /clear, /compact, /cost, /model, /status

Wiederverbindungs-Strategie

Mobile Apps leben in einer feindlichen Netzwerkumgebung. Ihr Telefon wechselt zwischen WiFi und Mobilfunk, fährt in Aufzüge, geht in den Ruhezustand. Die Wiederverbindungs-Strategie der App handhabt all das:

1. Verbindungsabbruch erkannt: WebSocket-Close-Event wird ausgelöst
2. Exponentielles Backoff: Wiederholung nach min(attempts * 3, 15) Sekunden, bis zu 5 Versuche
3. Hintergrund-Bewusstsein: Wenn die App im Hintergrund ist, Wiederverbindung überspringen. Flag setzen für Wiederverbindung beim Vordergrund-Wechsel
4. Session-Wiederherstellung: Bei Wiederverbindung: Sessions auflisten → zuvor aktive Session finden → erneut verbinden → Ausgabe mit 0,2s, 0,7s und 1,5s Verzögerung abfragen

Das gestaffelte Ausgabe-Polling (0,2s, 0,7s, 1,5s) nach der Wiederverbindung behandelt den Fall, dass tmux einen Moment braucht, um nach der erneuten Verbindung ein Capture zu erzeugen. Ein einzelnes sofortiges Polling würde oft leeren Inhalt zurückgeben.

Terminal-Buffer

Der TerminalBuffer ist ein zirkulärer Buffer, begrenzt auf 500.000 Zeichen und 10.000 Zeilen. Bei Überlauf wird Inhalt von vorne abgeschnitten, mit Ausrichtung an der nächsten Zeilengrenze, damit nie eine partielle erste Zeile angezeigt wird.

Dieses Limit existiert, weil AttributedString-Rendering bei großen Mengen teuer wird. 500K Zeichen entsprechen ungefähr 30 Minuten intensiver Claude Code-Ausgabe — genug für jede vernünftige Session bei responsiver UI.

Die Mac-Companion-App

Die Mac-Companion-App ist eine Menüleisten-Anwendung, die den Node.js-Server, den Cloudflare Tunnel und System-Einstellungen verwaltet.

Server-Bundling

Der gesamte Node.js-Server ist in der Mac App gebündelt. Beim ersten Start kopiert sie die Server-Dateien nach ~/Library/Application Support/ClaudeCodeRemote/Server/. Bei späteren Starts vergleicht sie Dateien Byte-für-Byte und kopiert nur geänderte Dateien. npm install wird nur erneut ausgeführt, wenn sich package.json geändert hat.

Das bedeutet, Benutzer müssen nie das Terminal berühren, um den Server zu installieren oder zu aktualisieren.

Abhängigkeitserkennung

Die App prüft auf benötigte Tools (Node.js, tmux, Homebrew), indem sie zuerst bekannte Pfade scannt (/opt/homebrew/bin/, /usr/local/bin/), dann auf which zurückfällt. Wenn Abhängigkeiten fehlen, führt ein Setup-Bildschirm durch die Installation.

Ruhezustand-Verhinderung

Wenn der Server läuft, ruft die App IOPMAssertionCreateWithName auf, um den macOS-Ruhezustand zu verhindern. Das ist essenziell — ein schlafender Mac kann keine WebSocket-Verbindungen bedienen.

Automatische Hook-Konfiguration

Die Companion-App schreibt Shell-Skripte nach ~/.claude/hooks/, die Lifecycle-Events an den lokalen Server POSTen. Das geschieht automatisch beim Server-Start — keine manuelle Konfiguration nötig.

Was wir nicht gebaut haben

Einige Dinge, die wir bewusst nicht gemacht haben:

Kein Terminal-Multiplexing in der App. Wir nutzen tmux auf der Server-Seite, aber die iPhone-App zeigt eine Session gleichzeitig. Split-Panes auf einem Telefonbildschirm wären unlesbar.

Keine Dateibearbeitung. Die App kann Dateien durchsuchen, aber nicht bearbeiten. Claude Code übernimmt die Dateibearbeitung — Sie sind der Prüfer, nicht der Editor. Einen mobilen Code-Editor hinzuzufügen wäre Feature-Creep, der die Kernerfahrung verschlechtert.

Kein Offline-Modus. Wenn Ihr Mac nicht erreichbar ist, zeigt die App den letzten bekannten Zustand, kann aber nichts Nützliches tun. Wir tun nicht so, als wäre es anders.

Kein Remote-Desktop-Fallback. Bildschirmfreigabe und VNC existieren, aber sie sind 10x schlechter für diesen Anwendungsfall. Tactic Remote sendet strukturierten Text, nicht Pixel. Das bedeutet geringere Bandbreite, geringere Latenz und eine UI, die für die Aufgabe gestaltet ist, statt eines geschrumpften Desktops.

Schnell-Einrichtung

Details überspringen? Hier das Minimum zum Starten.

Auf Ihrem Mac

1. Mac-Companion-App installieren von tacticremote.com/download
2. Starten — sie installiert automatisch Abhängigkeiten und startet den Server
3. QR-Code notieren, der in der App angezeigt wird

Auf Ihrem iPhone

1. Tactic Remote installieren von App Store
2. QR-Code scannen aus der Mac App
3. Session erstellen mit Verweis auf Ihr Projektverzeichnis
4. Claude starten und Ihren ersten Prompt senden

Für Remote-Zugriff (außerhalb Ihres Heimnetzwerks) aktivieren Sie den Cloudflare Tunnel-Schalter in den Mac-App-Einstellungen. Die App generiert automatisch eine öffentliche URL.

Benachrichtigungen konfigurieren

In der Mac App werden Hooks automatisch beim Server-Start konfiguriert. Auf dem iPhone gewähren Sie Benachrichtigungsberechtigungen, wenn Sie dazu aufgefordert werden. Das war's.

FAQ

Läuft Claude weiter, wenn ich die iPhone-App schließe?

Ja. Claude läuft in tmux auf Ihrem Mac. Die iPhone-App ist ein Fenster in diese Session. App schließen, Telefon in die Tasche — Claude arbeitet weiter. App wieder öffnen und Sie sehen alles, was in der Zwischenzeit passiert ist.

Was passiert bei Netzwerkausfall?

Die iPhone-App verbindet sich automatisch mit exponentiellem Backoff (bis zu 5 Versuche über ~45 Sekunden) wieder. Bei Wiederverbindung wird die vorherige Session erneut angehängt und die angesammelte Ausgabe abgerufen. Keine Arbeit geht verloren — tmux buffert alles auf der Mac-Seite.

Wie viel Akku verbraucht das?

Die iPhone-App unterhält keine persistente Hintergrundverbindung. Im Hintergrund trennt sie sauber die Verbindung. Der Akku-Einfluss ist praktisch null, wenn Sie die App nicht aktiv nutzen.

Kann ich das mit anderen KI-Coding-Tools nutzen?

Tactic Remote ist um Claude Codes Terminal-Interface gebaut, aber die zugrundeliegende Architektur (tmux-Session-Verwaltung, Terminal-Streaming) funktioniert mit jedem terminalbasierten Tool. Wenn es in einem Terminal läuft, kann der Server es verwalten. Die Zustandserkennungs-Heuristiken sind Claude Code-spezifisch, aber die grundlegende Send-Keys/Capture-Pane-Schleife ist universell.

Ist mein Code sicher?

Ihr Code verlässt nie Ihren Mac. Tactic Remote überträgt Terminal-Text über verschlüsselte WebSocket-Verbindungen. Der Server hat keine Cloud-Komponente, keine Telemetrie und keine Analytik. Bei Nutzung von Cloudflare Tunnel ist der Datenverkehr Ende-zu-Ende verschlüsselt — Cloudflare proxied verschlüsselte Frames, nicht Ihren Quellcode.

Wenn Sie tiefer in spezifische Subsysteme eintauchen möchten, siehe Warum wir tmux als Session-Backbone gewählt haben, Echtzeit-Terminal-Streaming aufbauen und die Sicherheitsmodell-Dokumentation.