# Gemini CLI Push-Benachrichtigungen: fertig oder wartet auf Freigabe

> Sende dir eine Push-Benachrichtigung aufs Handy, wenn Gemini CLI einen Durchlauf beendet oder ein Tool ausführen möchte. Zwei Hooks in settings.json, ein Skript und der Pocket-Alert-MCP-Server.

*15.10.2026*

<!-- source: https://pocketalert.app/de/blog/gemini-cli-notifications -->

Gemini CLI kann dich auch von sich aus benachrichtigen, aber nur im Terminal: Aktivierst du `general.enableNotifications`, sendet es eine Desktop-Benachrichtigung oder einen Signalton, wenn es fertig ist oder dich braucht. Das hilft, wenn du am Rechner sitzt und das Terminal in einem anderen Tab offen hast. Wenn du nicht am Rechner bist, bringt es nichts.

Hooks schließen diese Lücke. Seit v0.26 sind sie standardmäßig aktiv, und zwei der Ereignisse sind genau das, wofür eine Push-Benachrichtigung aufs Handy gemacht ist:

- **AfterAgent**: Gemini hat seinen Durchlauf beendet. Die Payload enthält die Antwort.
- **Notification**: Gemini bittet um Erlaubnis, ein Tool auszuführen.

Diese Anleitung schickt beides über Pocket Alert auf dein Handy.

## Ein Hinweis zu welchem Gemini CLI

Seit dem 18. Juni 2026 schreibt Googles Dokumentation, dass Gemini CLI für den kostenlosen Tarif und die Google-One-Pläne durch Antigravity CLI ersetzt wurde. Gemini CLI selbst läuft weiter mit einem kostenpflichtigen Gemini-API-Schlüssel, über Vertex AI oder mit Enterprise-Zugang, und genau das behandelt diese Anleitung. Wenn du Antigravity CLI nutzt, schau für Hooks in dessen Dokumentation nach.

## Was du brauchst

- Gemini CLI v0.26 oder neuer.
- `jq` und `curl`.
- Ein Pocket-Alert-Konto, einen API-Schlüssel von [API-Schlüssel](/account/apikeys) und die [App](/get-app) auf deinem Handy. Der kostenlose Tarif reicht.

Speichere den Schlüssel in einer Datei. Gemini CLI kann Umgebungsvariablen, deren Name `KEY` oder `TOKEN` enthält, vor dem Ausführen von Hooks entfernen, wenn die Schwärzung von Umgebungsvariablen aktiv ist oder es in GitHub Actions läuft. Ein Schlüssel, der aus einer Datei gelesen wird, ist davon nicht betroffen:

```bash
mkdir -p ~/.config/pocketalert
printf '%s' 'YOUR_API_KEY' > ~/.config/pocketalert/key
chmod 600 ~/.config/pocketalert/key
```

## Schritt 1: Das Hook-Skript

Gemini CLI schickt jedem Hook ein JSON-Objekt über stdin, mit `hook_event_name` und `cwd`. `AfterAgent` ergänzt `prompt_response`, `Notification` ergänzt `notification_type` und `message`. Speichere es als `~/.gemini/hooks/pocketalert.sh`:

```bash
#!/usr/bin/env bash
payload=$(cat)
project=$(basename "$(jq -r '.cwd' <<<"$payload")")

case "$(jq -r '.hook_event_name' <<<"$payload")" in
  AfterAgent)
    title="Gemini finished · $project"
    message=$(jq -r '.prompt_response // "Turn complete"' <<<"$payload")
    level=default ;;
  Notification)
    title="Gemini needs approval · $project"
    message=$(jq -r '.message // "Waiting for tool permission"' <<<"$payload")
    level=high ;;
  *) echo '{}'; exit 0 ;;
esac

jq -n --arg t "$title" --arg m "${message:0:300}" --arg l "$level" \
  '{title: $t, message: $m, level: $l}' |
  curl -sS --max-time 5 https://api.pocketalert.app/v1/messages \
    -H "Token: $(cat ~/.config/pocketalert/key)" \
    -H 'Content-Type: application/json' \
    --data-binary @- >/dev/null 2>&1 || true

echo '{}'
```

```bash
chmod +x ~/.gemini/hooks/pocketalert.sh
```

Gemini CLI wertet die Standardausgabe eines Hooks als JSON aus. Das Skript gibt deshalb nur `{}` aus, die Ausgabe von curl landet in `/dev/null`. Ein Exit-Code 2 aus einem `AfterAgent`-Hook würde die Antwort ablehnen und Gemini zu einem Neuversuch zwingen, daher gibt das Skript ihn nie zurück.

### Oder mit der Pocket-Alert-CLI

Wenn du die [Pocket-Alert-CLI](/tools/cli) in Version 2.0 oder neuer installiert hast, schrumpft der curl-Block auf einen einzigen Befehl. Die CLI maskiert den Text selbst und liest den Schlüssel aus `pocketalert auth`, was zugleich die oben beschriebene Entfernung von Variablen umgeht:

```bash
pocketalert send -t "$title" -m "${message:0:300}" -l "$level" -q >/dev/null 2>&1 || true
```

Verwende `-t` und `-m` statt Positionsargumenten: Eine Antwort, die mit einem Bindestrich beginnt, etwa eine Markdown-Liste, würde sonst als Option gelesen.

## Schritt 2: Hooks registrieren

Ergänze in `hooks` einen `~/.gemini/settings.json`-Block, der mit dem vorhandenen Inhalt zusammengeführt wird:

```json
{
  "hooks": {
    "AfterAgent": [
      {
        "matcher": "*",
        "hooks": [
          {
            "name": "pocketalert-done",
            "type": "command",
            "command": "/Users/you/.gemini/hooks/pocketalert.sh",
            "timeout": 10000
          }
        ]
      }
    ],
    "Notification": [
      {
        "matcher": "*",
        "hooks": [
          {
            "name": "pocketalert-approval",
            "type": "command",
            "command": "/Users/you/.gemini/hooks/pocketalert.sh",
            "timeout": 10000
          }
        ]
      }
    ]
  }
}
```

Ersetze `/Users/you` durch dein Home-Verzeichnis. `timeout` steht hier in Millisekunden, anders als bei manchen anderen Agenten. Für ein einzelnes Projekt legst du denselben Block in `.gemini/settings.json` im Repository ab; Gemini CLI führt Projekt-Hooks nur in einem vertrauenswürdigen Ordner aus.

## Schritt 3: Testen

Starte das Skript zuerst mit einem künstlichen Ereignis:

```bash
echo '{"hook_event_name":"AfterAgent","cwd":"/tmp/demo","prompt_response":"Hook test"}' \
  | ~/.gemini/hooks/pocketalert.sh
```

Starte dann Gemini CLI und gib ihm eine Aufgabe, die mit einem Tool-Aufruf endet, der Freigabe braucht, etwa „create a file called notes.txt“. Während es wartet, bekommst du **Gemini needs approval**, und nachdem du zugestimmt hast und der Durchlauf endet, **Gemini finished**.

## Was auf deinem Handy ankommt

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Ereignis</th><th>Titel</th><th>Inhalt</th><th>Stufe</th></tr></thead>
<tbody>
<tr><th>Durchlauf beendet</th><td>Gemini finished · api</td><td>Die ersten 300 Zeichen der Antwort</td><td>default</td></tr>
<tr><th>Tool-Erlaubnis</th><td>Gemini needs approval · api</td><td>Die Erlaubnismeldung von Gemini CLI</td><td>high</td></tr>
</tbody>
</table>
</div>

`high` kommt auf dem iPhone als zeitkritisch an, sodass Freigabeanfragen den Fokus-Modus durchbrechen. Jede Push-Benachrichtigung bleibt in der App und im Web-Dashboard erhalten.

## Oder lass Gemini über MCP senden

Mit dem [Pocket-Alert-MCP-Server](/tools/mcp) kann Gemini Push-Benachrichtigungen selbst verfassen und zu den Momenten senden, die du festlegst. Füge ihn über die Kommandozeile hinzu:

```bash
gemini mcp add --scope user --transport http \
  --header 'Authorization: Bearer $POCKETALERT_API_KEY' \
  pocketalert https://mcp.pocketalert.app/mcp
```

Die einfachen Anführungszeichen sorgen dafür, dass `$POCKETALERT_API_KEY` als Variable in der Einstellungsdatei stehen bleibt und der Schlüssel nicht hineingeschrieben wird. Gemini CLI löst die Variable beim Verbinden auf, exportiere sie also in der Shell, die `gemini` startet. Ohne `--scope user` wird der Server nur dem aktuellen Projekt hinzugefügt.

Das Ergebnis in `~/.gemini/settings.json`:

```json
{
  "mcpServers": {
    "pocketalert": {
      "url": "https://mcp.pocketalert.app/mcp",
      "type": "http",
      "headers": { "Authorization": "Bearer $POCKETALERT_API_KEY" }
    }
  }
}
```

Führe `/mcp` innerhalb von Gemini CLI aus, um den Server und seine Tools zu sehen. Eine Anweisung wie „run the migration and push me the row count when it's done“ endet dann mit einem Aufruf von `create_message`.

## Wenn nichts ankommt

- **Führe den Testbefehl aus.** Kommt keine Push-Benachrichtigung, liegt es am Schlüssel oder am Netzwerk. Entferne `>/dev/null 2>&1`, um die Antwort von curl zu sehen.
- **Prüfe, ob Hooks aktiviert sind.** Sie sind standardmäßig aktiv, doch `hooksConfig.enabled: false` in den Einstellungen schaltet sie ab.
- **Prüfe den Pfad** in `command`. Er muss absolut sein, und das Skript muss ausführbar sein.
- **Prüfe die Standardausgabe.** Alles andere als JSON auf stdout führt dazu, dass Gemini CLI das Ergebnis des Hooks ignoriert. Stelle sicher, dass das Skript sonst nichts ausgibt.

## FAQ

### Worin unterscheidet sich das von `general.enableNotifications`?

Diese Einstellung sendet Benachrichtigungen aus dem Terminal an deinen Rechner, wenn Gemini dich braucht oder fertig ist. Hooks führen beliebige Befehle aus, deshalb können sie dein Handy erreichen, einen Verlauf führen und mit Prioritätsstufen arbeiten.

### Kann ich den Tool-Aufruf vom Handy aus freigeben?

Mit diesem Skript nicht: Es meldet dir nur, dass Gemini wartet, und du gibst die Freigabe im Terminal. Ein `BeforeTool`-Hook kann einen Tool-Aufruf blockieren, ein Freigabe-Gate ist also mit einem Endpunkt möglich, den dein Handy aufruft. [Human-in-the-loop-Benachrichtigungen](/blog/human-in-the-loop-notifications) zeigt das Muster.

### Funktioniert das in GitHub Actions?

Ja, und dort ist der Ansatz mit der Schlüsseldatei wichtig: In GitHub Actions entfernt Gemini CLI Variablen mit `KEY` oder `TOKEN` im Namen aus der Umgebung des Hooks. Schreibe den Schlüssel aus einem Secret in einem früheren Schritt in eine Datei.

### Ist es kostenlos?

Hooks gehören zu Gemini CLI, und der kostenlose Tarif von Pocket Alert umfasst 50 Nachrichten am Tag auf einem Gerät. Gemini selbst braucht für die CLI einen kostenpflichtigen API-Schlüssel oder Enterprise-Zugang, wie oben erwähnt.

[Hol dir einen API-Schlüssel](/signup), ergänze die Hooks und lass dich von Gemini finden, wenn es dich braucht.
