# CLI Pocket Alert 2.1 : niveaux, exec, watch et boîte de réception dans votre terminal

> La CLI Pocket Alert est réécrite et open source. Envoyez avec niveaux, boutons, images et envois programmés, encapsulez n’importe quelle commande avec exec, transformez les lignes de log en notifications push avec watch et parcourez tout dans une interface terminal plein écran.

*17.10.2026*

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

La première CLI Pocket Alert ne pouvait envoyer qu’un titre et un message. C’était suffisant pour prouver l’idée, mais guère plus : pas de niveaux de priorité, pas de boutons, pas d’envoi programmé, et rien pour la tâche la plus courante de toutes, vous prévenir quand une longue commande se termine.

La version 2 est une réécriture. Elle vit dans son propre dépôt sous licence MIT, s’installe avec une seule commande et couvre tout ce que l’API permet de faire. La version 2.1, disponible aujourd’hui, ajoute `pocketalert ui` : une application terminal plein écran pour votre boîte de réception, vos messages programmés, vos applications, vos appareils et vos webhooks.

![La boîte de réception de la CLI Pocket Alert dans le terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-inbox.jpg)

## Installation

**macOS et 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 :** téléchargez [pocketalert_windows_amd64.zip](https://github.com/PocketAlert/cli/releases/latest/download/pocketalert_windows_amd64.zip) depuis la dernière version et placez `pocketalert.exe` dans votre PATH. Chaque version fournit des archives pour macOS et Linux sur Intel et ARM, et pour Windows sur x64, accompagnées de sommes de contrôle.

Connectez-vous ensuite une fois avec une clé API depuis [Clés API](/account/apikeys) :

```bash
pocketalert auth
```

La clé est saisie dans une invite masquée, vérifiée auprès de l’API, puis enregistrée dans `~/.pocketalert/config.json` avec le mode `600`. En CI, définissez plutôt `POCKETALERT_API_KEY` ; sa valeur prime sur la clé enregistrée.

## Envoyer, avec tout ce que propose l’API

La forme de base prend désormais deux arguments :

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

Le message peut provenir de l’entrée standard, ce qui envoie directement la sortie d’une commande sur votre téléphone :

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

Le reste passe par des options :

- **Niveaux.** `-l silent|low|default|high|critical`, ou `-2` à `2`. `critical` passe outre le mode Ne pas déranger sur les offres payantes ; sur l’offre gratuite, il est reçu comme `high`.
- **Programmation.** `--at "2026-10-20 09:50"` dans le fuseau horaire de votre compte, ou `--in 1d12h`. Jusqu’à 30 jours à l’avance, sur les offres payantes. `pocketalert scheduled list` et `scheduled cancel <tid>` gèrent les envois en attente.
- **Boutons d’action.** Jusqu’à trois `--action type:label:value`, où le type est `view`, `http` ou `copy`. Sur les offres payantes.
- **Images.** `--image ./screenshot.png` ou une URL `https://`. Sur les offres payantes.
- **Cibles.** `-a` pour une application, `-d` pour un appareil.
- **Scripts.** `-q` n’affiche que l’identifiant du message, et chaque commande accepte `--json` pour obtenir la réponse brute de l’API.

Un échec de déploiement avec toutes ces options à la fois :

```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"
```

Un bouton `http` envoie un POST par défaut. Écrivez `http:Ack:GET https://…` pour une autre méthode, ou passez la forme JSON complète avec les en-têtes et le corps.

## exec : une notification push à la fin d’une commande

Ce pour quoi beaucoup de gens écrivaient un script wrapper est désormais intégré. `exec` lance une commande, affiche sa sortie comme d’habitude, puis envoie une notification push à la fin :

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

Le titre de la notification est la commande précédée d’un ✓, ou d’un ✗ suivi du code de sortie. Le corps indique la durée, le nom de l’hôte et les dix dernières lignes de sortie. Les échecs sont envoyés en `high` sauf si vous définissez un niveau, et le code de sortie de la commande est transmis : `exec` peut donc être utilisé sans risque dans les scripts, cron et la CI.

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

`--on` détermine quand notifier : `always`, `success` ou `failure`. `--tail` fixe le nombre de lignes de sortie à inclure, ou `0` pour aucune.

## watch : des lignes de log en notifications push

`watch` lit des lignes depuis un tube et les envoie sous forme de notifications :

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

Les lignes qui arrivent dans la fenêtre de regroupement, cinq secondes par défaut, sont regroupées en une seule notification avec le nombre de lignes dans le titre. Une rafale de deux cents erreurs ne consomme ainsi qu’un message de votre quota quotidien, et non deux cents.

## pocketalert ui

Lancez `pocketalert ui` et le terminal devient un client Pocket Alert. Cinq onglets, à parcourir avec `tab` ou `1` à `5` : Boîte de réception, Programmés, Applications, Appareils et Webhooks.

La **boîte de réception** liste les messages avec leur niveau, leur application et leur heure ; les messages non lus sont marqués d’un point. Le volet de droite affiche le message sélectionné en entier, avec ses boutons d’action et leurs cibles. Recherchez avec `/`, affichez uniquement les non-lus avec `u`, marquez un message comme lu avec `r` ou tous avec `a`. Les nouveaux messages apparaissent automatiquement tant que l’application est ouverte.

![Un message avec boutons d’action dans le volet d’aperçu](https://cdn.pocketalert.app/blog/pocketalert-cli-2-actions.jpg)

`n` ouvre le **compositeur** : titre et message, puis application, appareil, niveau, heure d’envoi, image et jusqu’à trois boutons d’action, chacun au même format `type:label:value` que les options de `send`. `ctrl+s` envoie. `f` sur un message existant le rouvre dans le compositeur, pour le renvoyer ou l’utiliser comme modèle.

![Rédaction d’un nouveau message dans le terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-compose.jpg)

Les autres onglets gèrent le reste du compte. **Applications** affiche chacune avec son niveau par défaut ; créez, renommez, modifiez le niveau ou supprimez sans quitter le clavier, et appuyez sur `enter` pour voir les messages de cette application. **Appareils** liste vos téléphones et permet de les renommer ou de les supprimer. **Webhooks** affiche vos webhooks avec leur historique de requêtes, et `y` copie l’URL d’un webhook. **Programmés** montre ce qui est en attente et annule un envoi avec `d`.

![Applications dans l’interface terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-applications.jpg)

Chaque action destructive demande d’abord confirmation, et `?` affiche tous les raccourcis.

## Gérer le compte depuis des scripts

Le reste de l’API est aussi couvert, et chaque commande accepte `--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"
```

Depuis la CLI, vous pouvez désormais définir un niveau par défaut pour les applications et les webhooks, ainsi que des boutons d’action sur les webhooks, avec des espaces réservés `%field.path%` remplis à partir de la charge utile. Une alerte Grafana peut ainsi arriver en `high` avec un bouton qui ouvre ce panneau précis.

La complétion shell pour zsh, bash et fish est fournie par `pocketalert completion`.

## Passer de la 1.x à la 2.x

Installez la 2.1 avec l’une des méthodes ci-dessus : elle remplace l’ancien binaire et conserve votre clé enregistrée. Trois changements peuvent affecter vos scripts existants :

- **Un message est désormais obligatoire.** `pocketalert send -t "Cron OK"` sans `-m` renvoie une erreur. Ajoutez un message, transmettez-en un par le tube, ou utilisez `exec`, qui en génère un pour vous.
- **Ne mélangez pas les formes.** Utilisez soit `send "Title" "Message"`, soit `send -t "Title" -m "Message"`. `send -t "Title" "Message"` lit le second argument comme un titre et s’arrête là.
- **Privilégiez `-m` pour les textes générés.** Un message positionnel qui commence par un tiret, comme une liste Markdown produite par un agent IA, est lu comme une option. `-m "$text"` est toujours sûr.

Si vous téléchargez les archives de version dans un script de provisionnement, leur nom est désormais `pocketalert_<os>_<arch>.tar.gz`, et `.zip` sous Windows.

Plusieurs bogues de la 1.x sont corrigés au passage : `webhooks create` respecte désormais `--application` et `--device`, les URL des webhooks pointent vers le bon hôte, les erreurs sortent sur stderr au lieu de stdout, les titres non latins ne sont plus coupés au milieu d’un caractère, et atteindre la limite quotidienne affiche votre consommation et l’heure de réinitialisation au lieu d’un simple `429`.

## Où elle s’inscrit

La CLI est désormais le chemin le plus court entre un terminal et votre téléphone, et les guides de ce blog l’utilisent là où elle fait gagner des lignes. Pour les agents de code, les scripts de hooks des guides [Claude Code](/blog/claude-code-push-notifications), [Codex](/blog/codex-notifications) et [Cline et Aider](/blog/cline-aider-notifications) peuvent appeler `pocketalert send` au lieu de curl. Pour cron et la CI, `exec` remplace la plupart des one-liners `|| curl`.

[Installez la CLI](/tools/cli), exécutez `pocketalert auth`, puis essayez `pocketalert ui`.
