# Pocket Alert CLI 2.1: Prioritäten, exec, watch und ein Posteingang im Terminal

> Die Pocket Alert CLI ist neu geschrieben und Open Source. Sende Push-Benachrichtigungen mit Prioritäten, Buttons, Bildern und Zeitplänen, umhülle jeden Befehl mit exec, mach Logzeilen mit watch zu Push-Benachrichtigungen und durchsuche alles in einer Vollbild-Terminal-Oberfläche.

*17.10.2026*

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

Die erste Pocket Alert CLI konnte einen Titel und eine Nachricht senden. Das reichte, um die Idee zu beweisen, mehr aber auch nicht: keine Prioritätsstufen, keine Buttons, keine Zeitplanung und nichts für die häufigste Aufgabe überhaupt, nämlich dir Bescheid zu geben, wenn ein langer Befehl fertig ist.

Version 2 ist ein Neuaufbau. Sie liegt in einem eigenen Repository unter der MIT-Lizenz, lässt sich mit einem einzigen Befehl installieren und deckt alles ab, was die API kann. Version 2.1, heute erschienen, ergänzt `pocketalert ui`: eine Vollbild-Terminal-App für deinen Posteingang, geplante Nachrichten, Anwendungen, Geräte und Webhooks.

![Der Posteingang der Pocket Alert CLI im Terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-inbox.jpg)

## Installation

**macOS und Linux:**

```bash
curl -fsSL https://raw.githubusercontent.com/PocketAlert/cli/main/install.sh | sh
```

**Homebrew:**

```bash
brew install pocketalert/tap/pocketalert
```

**Go:**

```bash
go install github.com/PocketAlert/cli/cmd/pocketalert@latest
```

**Windows:** Lade [pocketalert_windows_amd64.zip](https://github.com/PocketAlert/cli/releases/latest/download/pocketalert_windows_amd64.zip) aus dem neuesten Release herunter und lege `pocketalert.exe` in deinen PATH. Jedes Release enthält Archive für macOS und Linux auf Intel und ARM sowie für Windows auf x64, jeweils mit Prüfsummen.

Melde dich dann einmalig mit einem API-Schlüssel von [API-Schlüssel](/account/apikeys) an:

```bash
pocketalert auth
```

Der Schlüssel wird in einer verdeckten Eingabeaufforderung eingegeben, gegen die API geprüft und mit dem Modus `~/.pocketalert/config.json` in `600` gespeichert. In CI setzt du stattdessen `POCKETALERT_API_KEY`; diese Variable hat Vorrang vor dem gespeicherten Schlüssel.

## Senden, mit allem, was die API bietet

Die Grundform besteht jetzt aus zwei Argumenten:

```bash
pocketalert send "Deploy finished" "v1.4.2 is live"
```

Die Nachricht kann von stdin kommen, sodass die Ausgabe eines Befehls direkt auf dein Handy wandert:

```bash
df -h | pocketalert send "Disk report"
```

Alles Weitere läuft über Flags:

- **Prioritäten.** `-l silent|low|default|high|critical` oder `-2` bis `2`. `critical` kommt auf kostenpflichtigen Tarifen auch durch „Nicht stören“; im kostenlosen Tarif wird es als `high` zugestellt.
- **Zeitplanung.** `--at "2026-10-20 09:50"` in der Zeitzone deines Kontos oder `--in 1d12h`. Bis zu 30 Tage im Voraus, auf kostenpflichtigen Tarifen. `pocketalert scheduled list` und `scheduled cancel <tid>` verwalten die Warteschlange.
- **Aktionsbuttons.** Bis zu drei `--action type:label:value`, wobei der Typ `view`, `http` oder `copy` ist. Auf kostenpflichtigen Tarifen.
- **Bilder.** `--image ./screenshot.png` oder eine `https://`-URL. Auf kostenpflichtigen Tarifen.
- **Ziele.** `-a` für eine Anwendung, `-d` für ein einzelnes Gerät.
- **Skripting.** `-q` gibt nur die Nachrichten-ID aus, und jeder Befehl akzeptiert `--json` für die rohe API-Antwort.

Ein fehlgeschlagenes Deployment mit allem auf einmal:

```bash
pocketalert send "Deploy failed" "main@4f2c" -l critical \
  --action "view:Open logs:https://ci.example.com/run/1" \
  --action "http:Retry:https://ci.example.com/run/1/retry" \
  --action "copy:Copy SHA:4f2c9e1"
```

Ein `http`-Button sendet standardmäßig einen POST. Schreib `http:Ack:GET https://…`, um eine andere Methode zu verwenden, oder übergib die vollständige JSON-Form mit Headern und Body.

## exec: eine Push-Benachrichtigung, wenn ein Befehl endet

Was die meisten früher in ein Wrapper-Skript gepackt haben, ist jetzt eingebaut. `exec` führt einen Befehl aus, zeigt seine Ausgabe wie gewohnt an und sendet eine Push-Benachrichtigung, sobald er endet:

```bash
pocketalert exec -- ./backup.sh
```

Der Titel der Push-Benachrichtigung ist der Befehl mit einem ✓ oder einem ✗ und dem Exit-Code. Der Text enthält die Dauer, den Hostnamen und die letzten zehn Zeilen der Ausgabe. Fehlschläge werden mit `high` gesendet, sofern du keine Priorität festlegst, und der Exit-Code des Befehls wird durchgereicht. `exec` ist daher sicher in Skripten, Cronjobs und CI.

```bash
pocketalert exec --on failure -l critical -- terraform apply -auto-approve
pocketalert exec -t "Nightly import" --tail 20 -- python import.py
```

`--on` legt fest, wann benachrichtigt wird: `always`, `success` oder `failure`. `--tail` bestimmt, wie viele Ausgabezeilen enthalten sind, oder `0` für keine.

## watch: Logzeilen als Push-Benachrichtigungen

`watch` liest Zeilen aus einer Pipe und sendet sie als Benachrichtigungen:

```bash
tail -f app.log | grep --line-buffered ERROR | pocketalert watch -t "app errors"
journalctl -fu nginx | pocketalert watch --batch 1m -l high
```

Zeilen, die innerhalb des Batch-Fensters eintreffen (standardmäßig fünf Sekunden), werden zu einer einzigen Push-Benachrichtigung mit Zeilenanzahl im Titel zusammengefasst. Ein Schwall von zweihundert Fehlern kostet dich eine Nachricht von deinem Tageslimit, nicht zweihundert.

## pocketalert ui

Starte `pocketalert ui`, und das Terminal wird zum Pocket-Alert-Client. Fünf Tabs, umschaltbar mit `tab` oder `1` bis `5`: Posteingang, Geplant, Anwendungen, Geräte und Webhooks.

Der **Posteingang** listet Nachrichten mit Priorität, Anwendung und Uhrzeit auf, ungelesene sind mit einem Punkt markiert. Das Feld rechts zeigt die ausgewählte Nachricht vollständig, einschließlich ihrer Aktionsbuttons und deren Ziele. Mit `/` suchst du, mit `u` zeigst du nur ungelesene an, mit `r` markierst du eine Nachricht als gelesen und mit `a` alle. Neue Nachrichten erscheinen automatisch, solange die App geöffnet ist.

![Eine Nachricht mit Aktionsbuttons in der Vorschau](https://cdn.pocketalert.app/blog/pocketalert-cli-2-actions.jpg)

Mit `n` öffnest du den **Editor**: Titel und Nachricht, dann Anwendung, Gerät, Priorität, Zustellzeitpunkt, Bild und bis zu drei Aktionsbuttons, jeweils in derselben `type:label:value`-Form wie die Flags von `send`. `ctrl+s` sendet. Mit `f` auf einer bestehenden Nachricht öffnest du sie erneut im Editor, um sie noch einmal zu senden oder als Vorlage zu nutzen.

![Eine neue Nachricht im Terminal verfassen](https://cdn.pocketalert.app/blog/pocketalert-cli-2-compose.jpg)

Die anderen Tabs verwalten den Rest des Kontos. **Anwendungen** zeigt jede mit ihrer Standardpriorität; du kannst sie erstellen, umbenennen, die Priorität ändern oder löschen, ohne die Tastatur zu verlassen, und mit `enter` die Nachrichten der Anwendung ansehen. **Geräte** listet deine Handys auf und lässt dich sie umbenennen oder entfernen. **Webhooks** zeigt deine Webhooks mit ihrem Anfrageverlauf, und mit `y` kopierst du eine Webhook-URL. **Geplant** zeigt, was in der Warteschlange steht, und mit `d` brichst du es ab.

![Anwendungen in der Terminal-Oberfläche](https://cdn.pocketalert.app/blog/pocketalert-cli-2-applications.jpg)

Jede destruktive Aktion fragt vorher nach, und mit `?` siehst du alle Tastenkürzel.

## Das Konto aus Skripten verwalten

Auch der Rest der API ist abgedeckt, und jeder Befehl akzeptiert `--json`:

```bash
pocketalert usage                                   # today's quota
pocketalert messages list -n 20
pocketalert messages read --all
pocketalert apps create -n "Production" -c "#EF4444" -l high
pocketalert webhooks create -n Grafana -m "%title%: %message%" -l high
pocketalert webhooks history <tid> --status error
pocketalert devices rename <tid> "Work phone"
```

Über die CLI kannst du jetzt eine Standardpriorität für Anwendungen und Webhooks setzen sowie Aktionsbuttons für Webhooks mit `%field.path%`-Platzhaltern, die aus dem Payload befüllt werden. So kann eine Grafana-Warnung als `high` ankommen, mit einem Button, der genau dieses Panel öffnet.

Shell-Vervollständigung für zsh, bash und fish gibt es über `pocketalert completion`.

## Upgrade von 1.x

Installiere 2.1 mit einer der oben genannten Methoden; sie ersetzt das alte Binary und behält deinen gespeicherten Schlüssel. Drei Änderungen können bestehende Skripte betreffen:

- **Eine Nachricht ist jetzt Pflicht.** `pocketalert send -t "Cron OK"` ohne `-m` gibt einen Fehler zurück. Füge eine Nachricht hinzu, leite eine per Pipe ein oder nutze `exec`, das eine für dich erzeugt.
- **Die Formen nicht mischen.** Verwende entweder `send "Title" "Message"` oder `send -t "Title" -m "Message"`. `send -t "Title" "Message"` liest das zweite Argument als Titel und bricht dann ab.
- **Für generierten Text `-m` bevorzugen.** Eine positionale Nachricht, die mit einem Bindestrich beginnt, etwa eine Markdown-Liste von einem KI-Agenten, wird als Option gelesen. `-m "$text"` ist immer sicher.

Die Release-Archive heißen jetzt `pocketalert_<os>_<arch>.tar.gz`, unter Windows `.zip`, falls du sie in einem Provisionierungsskript herunterlädst.

Unterwegs wurden einige Fehler aus 1.x behoben: `webhooks create` berücksichtigt jetzt `--application` und `--device`, Webhook-URLs zeigen auf den richtigen Host, Fehler gehen nach stderr statt stdout, nicht-lateinische Titel werden nicht mehr mitten im Zeichen abgeschnitten, und wer das Tageslimit erreicht, sieht seine Nutzung und den Zeitpunkt des Zurücksetzens statt eines nackten `429`.

## Wo sie passt

Die CLI ist jetzt der kürzeste Weg vom Terminal auf dein Handy, und die Anleitungen in diesem Blog nutzen sie überall dort, wo sie Zeilen spart. Für Coding-Agenten können die Hook-Skripte aus den Anleitungen zu [Claude Code](/blog/claude-code-push-notifications), [Codex](/blog/codex-notifications) und [Cline und Aider](/blog/cline-aider-notifications) statt curl den Befehl `pocketalert send` aufrufen. Für Cronjobs und CI ersetzt `exec` die meisten `|| curl`-Einzeiler.

[Installiere die CLI](/tools/cli), führe `pocketalert auth` aus und probiere `pocketalert ui` aus.
