# Push aufs iPhone, wenn Claude Code auf dich wartet

> Eine Push-Benachrichtigung aufs iPhone oder die Apple Watch, wenn Claude Code um Erlaubnis fragt oder fertig ist. Mit zwei Hooks und der honk-CLI.

Source: https://honk-honk.app/de/anleitungen/claude-code-push

Claude Code arbeitet oft minutenlang allein und hält dann an: Es braucht deine Erlaubnis für einen Befehl, oder es ist fertig und wartet auf deinen nächsten Prompt. Bist du nicht mehr am Terminal, wartet es genau so lange, wie du weg bist.

Für beide Momente hat Claude Code [Hooks](https://code.claude.com/docs/en/hooks). Ein `Notification`-Hook läuft, wenn es deine Erlaubnis braucht, ein `Stop`-Hook, wenn es eine Antwort beendet hat. Diese Anleitung verbindet beide mit Honk: Dein iPhone und deine Apple Watch sagen dir Bescheid, und eine Sitzung, die zehnmal anklopft, schickt eine Mitteilung statt zehn.

## Voraussetzungen

- Ein Honk-Konto (vorerst nur auf Einladung: [Zugang anfragen](https://honk-honk.app/de/zugang-anfragen)) und ein Projekt für deine Coding-Agents, etwa „Claude Code“, mit einem Ingest-Schlüssel. Gib diesem Projekt einen eigenen Schlüssel: Wer ihn hat, kann in dieses Projekt senden und nirgendwohin sonst.
- Die `honk`-CLI auf dem Rechner, auf dem Claude Code läuft: `go install github.com/honk-hq/go/cmd/honk@latest` oder ein Binary von der [Releases-Seite](https://github.com/honk-hq/go/releases).
- `jq`, um das JSON zu lesen, das Claude Code an Hooks übergibt. Aktuelle macOS-Versionen bringen es mit; unter Linux installierst du es mit deinem Paketmanager.

## 1. Den Schlüssel in eine Datei legen

Hooks laufen als Shell-Befehle in der Umgebung von Claude Code. Damit der Schlüssel nicht in Einstellungsdateien landet, die du vielleicht committest, leg ihn in `~/.config/honk/env` ab:

```sh
HONK_URL=https://honk-honk.app
HONK_KEY=honk_…
```

Führ danach `chmod 600 ~/.config/honk/env` aus, damit nur du die Datei lesen kannst.

## 2. Das Hook-Skript anlegen

Speichere das Skript als `~/.claude/hooks/honk.sh` und mach es mit `chmod +x` ausführbar:

```bash
#!/usr/bin/env bash
# A push when Claude Code needs your permission (Notification) or finishes (Stop).
# Claude Code sends the event as JSON on stdin. Every ping from one project
# shares a group key, so Honk folds repeats into one notification.
set -a; . "$HOME/.config/honk/env"; set +a
input=$(cat)
dir=${CLAUDE_PROJECT_DIR:-$(jq -r '.cwd // empty' <<<"$input")}
project=$(basename "${dir:-$PWD}")

case $(jq -r '.hook_event_name' <<<"$input") in
  Notification)
    level=loud
    title="Claude Code needs you in $project"
    text=$(jq -r '.message // empty' <<<"$input") ;;
  Stop)
    level=light
    title="Claude Code finished in $project"
    text=$(jq -r '.last_assistant_message // empty | .[:280]' <<<"$input") ;;
  *) exit 0 ;;
esac

honk send --severity "$level" --title "$title" --message "${text:-$title}" \
  --group-key "claude-code/$project" --source "$(hostname -s)" --quiet || true
```

Es liest das Ereignis, das Claude Code über stdin schickt, und macht daraus ein Honk-Ereignis:

- **Braucht eine Erlaubnis:** ein Lautes Hupen mit dem Titel „Claude Code needs you in my-app“ und der Meldung von Claude Code selbst, etwa „Claude needs your permission“.
- **Fertig:** ein Leichtes Hupen mit dem Titel „Claude Code finished in my-app“ und den ersten 280 Zeichen der letzten Antwort.

Die Titel stehen im Skript, du kannst sie also auf Deutsch schreiben. `|| true` sorgt dafür, dass ein Netzwerkproblem nie zum Hook-Fehler wird.

## 3. Die Hooks eintragen

Trag beide Hooks in `~/.claude/settings.json` ein. Diese Datei gilt für alle Projekte auf diesem Rechner. Hat die Datei schon einen `hooks`-Schlüssel, ergänze `Notification` und `Stop` neben den Ereignissen, die schon da sind:

```json
{
  "hooks": {
    "Notification": [
      {
        "matcher": "permission_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/honk.sh",
            "async": true
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/honk.sh",
            "async": true
          }
        ]
      }
    ]
  }
}
```

- `"matcher": "permission_prompt"` beschränkt den `Notification`-Hook auf Berechtigungsanfragen. Der `Stop`-Hook hat keinen Matcher: Er läuft am Ende jeder Antwort.
- `"async": true` lässt den Hook im Hintergrund laufen, sodass Claude Code nie auf den Push wartet.

Derselbe Block funktioniert auch in der `.claude/settings.json` eines Repositorys, die du committen und so mit deinem Team teilen kannst (dann braucht jede Person das Skript, die CLI und einen eigenen Schlüssel), oder in `.claude/settings.local.json` für ein einzelnes Projekt, nur auf deinem Rechner.

Tipp `/hooks` in Claude Code ein, um zu prüfen, ob beide Hooks aufgeführt sind. Um das Skript zu testen, ohne auf Claude zu warten, führ Folgendes aus:

```sh
echo '{"hook_event_name":"Notification","message":"Test from the terminal"}' | ~/.claude/hooks/honk.sh
```

## Eine Mitteilung pro Projekt, nicht eine pro Ping

Alle Ereignisse eines Projekts nutzen den Gruppenschlüssel `claude-code/<project>`, Honk hält sie also in einer Gruppe. Davon hängt ab, wie oft dein Handy vibriert:

- Der erste Ping kommt sofort als Push.
- Die folgenden lösen keinen eigenen Push aus. Du bekommst höchstens alle 5 Minuten ein Update mit der aktuellen Anzahl, und auf dem iPhone ersetzt jedes Update die vorige Mitteilung, statt eine weitere hinzuzufügen.
- Eine Stufe, die lauter ist als alles, was die Gruppe bisher gepusht hat, kommt sofort durch, auch innerhalb dieser 5 Minuten: zum Beispiel eine Berechtigungsanfrage (Lautes Hupen) nach einer fertigen Antwort (Leichtes Hupen).

Beide Werte findest du in den **Einstellungen** des Projekts. **Solange sich ein Problem wiederholt, höchstens einmal pro … melden** ändert die 5 Minuten. Nach einem Tag ohne Ping zählt der nächste als neu und kommt sofort als Push; **Nachrichten gruppieren, die weniger als … auseinanderliegen** verkürzt diesen Tag, sodass jede neue Arbeitssitzung mit einem Push beginnt.

## Ruhiger: nur, wenn du weg bist

Der `Stop`-Hook läuft nach jeder Antwort, auch wenn du gerade aufs Terminal schaust. Willst du nur einen Push, wenn du weg bist, lösch den `Stop`-Block und setz den Matcher auf `"permission_prompt|idle_prompt"`. Claude Code meldet `idle_prompt`, wenn es vor etwa 60 Sekunden fertig geworden ist und du seitdem nichts getippt hast. Ein Push heißt dann: Es wartet wirklich auf dich.

## Was der Push zeigt

Die Mitteilung zeigt Titel und Nachricht, und die Nachricht kann der Anfang von Claudes Antwort sein, Code inklusive. Für vertrauliche Arbeit öffne die **Einstellungen** des Projekts und stell **Was Mitteilungen zeigen** auf **Allgemein (ohne Inhalt)**: Der Push zeigt dann nur noch den Projektnamen, und der Text bleibt im Posteingang. Oder lass die Antwort ganz aus dem Skript weg.

## Codex

Die Codex-CLI von OpenAI hat einen einfacheren Hook: `notify` startet nach jedem abgeschlossenen Durchgang ein Programm und übergibt ihm das Ereignis als ein einziges JSON-Argument. Dieses Skript schickt dasselbe Leichte Hupen, in einer eigenen Gruppe:

```bash
#!/usr/bin/env bash
# Codex runs this after each finished turn, with the event as one JSON argument.
set -a; . "$HOME/.config/honk/env"; set +a
project=$(basename "$(jq -r '.cwd // "codex"' <<<"$1")")
text=$(jq -r '."last-assistant-message" // empty | .[:280]' <<<"$1")

honk light "Codex finished in $project" "${text:-Done.}" \
  --group-key "codex/$project" --source "$(hostname -s)" --quiet || true
```

Speichere es als `~/.codex/honk.sh`, mach es ausführbar und ergänze eine Zeile in `~/.codex/config.toml`, mit deinem eigenen Benutzerordner im Pfad:

```toml
# a top-level key: put it above the first [section]
notify = ["/Users/you/.codex/honk.sh"]
```

Codex schickt derzeit nur abgeschlossene Durchgänge (`agent-turn-complete`) an `notify`. Das deckt also das Ende einer Aufgabe ab, nicht Freigabeanfragen.