# Notifications push Gemini CLI : terminé ou en attente d’approbation

> Recevez une notification push sur votre téléphone quand Gemini CLI termine un tour ou demande l’exécution d’un outil. Deux hooks dans settings.json, un script, et le serveur MCP de Pocket Alert.

*15.10.2026*

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

Gemini CLI peut vous prévenir de lui-même, mais uniquement dans le terminal : activez `general.enableNotifications` et il envoie une notification sur le bureau ou un signal sonore lorsqu’il a terminé ou qu’il a besoin de vous. C’est utile quand vous êtes devant l’ordinateur et que le terminal se trouve dans un autre onglet. Cela ne sert à rien quand vous n’êtes pas devant l’ordinateur.

Les hooks comblent ce manque. Depuis la v0.26, ils sont activés par défaut, et deux de leurs événements correspondent exactement à ce pour quoi une notification push sur téléphone est faite :

- **AfterAgent** : Gemini a terminé son tour. La charge utile contient la réponse.
- **Notification** : Gemini demande l’autorisation d’exécuter un outil.

Ce guide envoie les deux sur votre téléphone via Pocket Alert.

## Une précision sur la version de Gemini CLI

Depuis le 18 juin 2026, la documentation de Google indique que Gemini CLI a été remplacé par Antigravity CLI pour l’offre gratuite et les formules Google One. Gemini CLI continue de fonctionner avec une clé API Gemini payante, Vertex AI ou un accès entreprise, et c’est ce que couvre ce guide. Si vous utilisez Antigravity CLI, consultez sa documentation pour les hooks.

## De quoi avez-vous besoin

- Gemini CLI v0.26 ou ultérieure.
- `jq` et `curl`.
- Un compte Pocket Alert, une clé API depuis [Clés API](/account/apikeys) et l’[application](/get-app) sur votre téléphone. L’offre gratuite suffit.

Enregistrez la clé dans un fichier. Gemini CLI peut supprimer les variables d’environnement dont le nom contient `KEY` ou `TOKEN` avant d’exécuter les hooks, lorsque la réduction des variables d’environnement est active ou lorsqu’il s’exécute dans GitHub Actions. Une clé lue depuis un fichier n’est pas concernée :

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

## Étape 1 : le script du hook

Gemini CLI envoie à chaque hook un objet JSON sur stdin contenant `hook_event_name` et `cwd`. `AfterAgent` ajoute `prompt_response`, et `Notification` ajoute `notification_type` et `message`. Enregistrez le fichier sous `~/.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 analyse la sortie standard d’un hook comme du JSON. Le script n’affiche donc que `{}`, rien d’autre : la sortie de curl part dans `/dev/null`. Un code de sortie 2 depuis un hook `AfterAgent` rejetterait la réponse et forcerait Gemini à réessayer. Le script ne le renvoie donc jamais.

### Ou avec la CLI Pocket Alert

Si la [CLI Pocket Alert](/tools/cli) 2.0 ou ultérieure est installée, le bloc curl se réduit à une seule commande. La CLI échappe elle-même le texte et récupère la clé via `pocketalert auth`, ce qui contourne aussi la suppression de variables décrite plus haut :

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

Conservez `-t` et `-m` plutôt que des arguments positionnels : une réponse qui commence par un tiret, comme une liste Markdown, serait sinon lue comme une option.

## Étape 2 : enregistrer les hooks

Ajoutez un bloc `hooks` dans `~/.gemini/settings.json`, fusionné avec le contenu existant :

```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
          }
        ]
      }
    ]
  }
}
```

Remplacez `/Users/you` par votre répertoire personnel. Ici, `timeout` est exprimé en millisecondes, contrairement à certains autres agents. Pour un seul projet, placez le même bloc dans `.gemini/settings.json` à la racine du dépôt : Gemini CLI n’exécute les hooks de projet que dans un dossier de confiance.

## Étape 3 : tester

Lancez d’abord le script avec un événement fictif :

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

Lancez ensuite Gemini CLI avec une tâche qui se termine par un appel d’outil nécessitant une approbation, par exemple « crée un fichier nommé notes.txt ». Vous recevez **Gemini needs approval** pendant qu’il attend, puis **Gemini finished** une fois que vous l’avez autorisé et que le tour se termine.

## Ce qui arrive sur votre téléphone

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Événement</th><th>Titre</th><th>Corps</th><th>Niveau</th></tr></thead>
<tbody>
<tr><th>Tour terminé</th><td>Gemini finished · api</td><td>Les 300 premiers caractères de la réponse</td><td>default</td></tr>
<tr><th>Autorisation d’outil</th><td>Gemini needs approval · api</td><td>Le message d’autorisation envoyé par Gemini CLI</td><td>high</td></tr>
</tbody>
</table>
</div>

Sur iPhone, `high` arrive comme une notification time-sensitive, ce qui permet aux demandes d’approbation de passer le mode Concentration. Chaque notification push reste consultable dans l’application et dans le tableau de bord web.

## Ou laisser Gemini l’envoyer via MCP

Avec le [serveur MCP Pocket Alert](/tools/mcp), Gemini peut envoyer lui-même des notifications push, aux moments que vous lui indiquez. Ajoutez-le depuis la ligne de commande :

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

Les guillemets simples conservent `$POCKETALERT_API_KEY` comme variable dans le fichier de paramètres, au lieu d’y écrire la clé. Gemini CLI la développe lors de la connexion : exportez donc la variable dans le shell qui lance `gemini`. Sans `--scope user`, le serveur n’est ajouté qu’au projet en cours.

Le résultat dans `~/.gemini/settings.json` :

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

Exécutez `/mcp` dans Gemini CLI pour voir le serveur et ses outils. Ensuite, une consigne du type « lance la migration et envoie-moi le nombre de lignes une fois terminé » se termine par un appel à `create_message`.

## Si rien n’arrive

- **Lancez la commande de test.** Pas de notification push signifie un problème de clé ou de réseau ; supprimez `>/dev/null 2>&1` pour voir la réponse de curl.
- **Vérifiez que les hooks sont activés.** Ils le sont par défaut, mais `hooksConfig.enabled: false` dans les paramètres les désactive.
- **Vérifiez le chemin** dans `command` : il doit être absolu, et le script doit être exécutable.
- **Vérifiez la sortie standard.** Tout ce qui n’est pas du JSON sur la sortie standard amène Gemini CLI à ignorer le résultat du hook. Assurez-vous qu’aucune autre partie du script n’affiche de texte.

## FAQ

### Quelle est la différence avec `general.enableNotifications` ?

Ce paramètre envoie des notifications du terminal sur votre ordinateur lorsque Gemini a besoin de vous ou a terminé. Les hooks exécutent n’importe quelle commande : ils peuvent donc atteindre votre téléphone, conserver un historique et utiliser des niveaux de priorité.

### Puis-je approuver l’appel d’outil depuis mon téléphone ?

Pas avec ce script : il vous indique que Gemini attend, et vous approuvez dans le terminal. Un hook `BeforeTool` peut bloquer un appel d’outil, donc une barrière d’approbation est possible avec un point d’accès que votre téléphone appelle ; [les notifications Human-in-the-loop](/blog/human-in-the-loop-notifications) présentent ce schéma.

### Cela fonctionne-t-il dans GitHub Actions ?

Oui, et l’approche par fichier de clé compte beaucoup ici : dans GitHub Actions, Gemini CLI supprime de l’environnement du hook les variables dont le nom contient `KEY` ou `TOKEN`. Écrivez la clé depuis un secret dans un fichier, dans une étape précédente.

### Est-ce gratuit ?

Les hooks font partie de Gemini CLI, et l’offre gratuite de Pocket Alert couvre 50 messages par jour sur un appareil. Gemini lui-même nécessite une clé API payante ou un accès entreprise pour la CLI, comme indiqué plus haut.

[Obtenez une clé API](/signup), ajoutez les hooks, et laissez Gemini vous trouver quand il a besoin de vous.
