# Notifications push pour Cline et Aider : sachez quand votre tour arrive

> Notifications push sur téléphone depuis deux agents de programmation open source. Cline dispose d’un hook TaskComplete et du serveur MCP de Pocket Alert ; Aider ne nécessite qu’une ligne dans .aider.conf.yml.

*16.10.2026*

<!-- source: https://pocketalert.app/fr/blog/cline-aider-notifications -->

Cline et Aider sont les deux agents de programmation open source que l’on laisse le plus souvent tourner en arrière-plan, et tous deux peuvent exécuter une commande lorsqu’il y a quelque chose à voir. Aucun des deux ne vous envoie quoi que ce soit sur votre téléphone de lui-même. Quelques lignes de configuration suffisent à changer cela.

- **Cline** exécute un script de hook lorsqu’une tâche se termine et parle MCP, il peut donc aussi envoyer des notifications push qu’il rédige lui-même.
- **Aider** exécute une commande de notification lorsqu’il attend votre saisie, après une réponse ou avant une confirmation oui/non.

Les deux passent par Pocket Alert, donc les notifications arrivent dans la même application, avec le même historique, que les alertes de tout le reste que vous faites tourner.

## De quoi avez-vous besoin

- Un compte Pocket Alert, une clé API issue de [Clés API](/account/apikeys), et l’application sur votre téléphone [iPhone ou Android](/get-app). L’offre gratuite suffit.
- `curl`, ainsi que `jq` pour le hook de Cline.

Enregistrez la clé dans un fichier. Les éditeurs lancés depuis le Dock sous macOS ne lisent pas votre profil shell : un fichier est donc le seul emplacement que les deux agents trouveront toujours :

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

## Cline

### Un hook pour les tâches terminées

Les hooks de Cline sont des fichiers exécutables nommés d’après l’événement. Placez un script nommé `TaskComplete`, sans extension, dans `~/Documents/Cline/Hooks/` et Cline l’exécutera à chaque fin de tâche, dans n’importe quel espace de travail. Pour un seul projet, utilisez plutôt `.clinerules/hooks/TaskComplete` dans le dépôt.

Le script reçoit un objet JSON sur l’entrée standard. Pour `TaskComplete`, les champs utiles sont `taskComplete.taskMetadata.result`, la réponse finale de Cline, et `workspaceRoots`, les dossiers ouverts. Il existe aussi un champ `initialTask`, mais l’extension actuelle l’envoie vide :

```bash
#!/usr/bin/env bash
payload=$(cat)
project=$(basename "$(jq -r '.workspaceRoots[0] // "Cline"' <<<"$payload")")
result=$(jq -r '.taskComplete.taskMetadata.result // "" | if . == "" then "Done" else . end' <<<"$payload")

jq -n --arg t "Cline finished · $project" --arg m "${result:0:300}" \
  '{title: $t, message: $m}' |
  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 '{"cancel":false,"contextModification":"","errorMessage":""}'
```

```bash
mkdir -p ~/Documents/Cline/Hooks
# save the script above as ~/Documents/Cline/Hooks/TaskComplete, then:
chmod +x ~/Documents/Cline/Hooks/TaskComplete
```

La dernière ligne est la réponse du hook pour Cline : ne pas annuler, n’ajouter aucun contexte, aucune erreur. Les hooks disposent d’une limite de 30 secondes, c’est pourquoi curl abandonne au bout de cinq.

Vérifiez que les hooks sont activés : le bouton **Hooks** dans les paramètres de fonctionnalités de Cline est activé par défaut. Les hooks s’exécutent sous macOS et Linux sous forme de scripts shell ; sous Windows, Cline attend un script PowerShell nommé `TaskComplete.ps1`.

### Et si « Cline attend une approbation » ?

La liste des hooks de Cline inclut un événement `Notification` précisément pour cela, mais dans la version 4.x actuelle de l’extension, il est défini sans être encore appelé. Tant que ce n’est pas le cas, il n’existe pas de hook fiable pour les demandes d’approbation : `PreToolUse` se déclenche avant chaque outil, y compris ceux approuvés automatiquement. Si vous voulez vous éloigner, la solution pratique consiste à élargir les paramètres d’approbation automatique de Cline pour les actions sûres, et à laisser `TaskComplete` vous prévenir lorsque le travail est terminé.

### Le serveur MCP

Cline est un client MCP, il peut donc aussi envoyer des notifications push via le [serveur MCP Pocket Alert](/tools/mcp). Ajoutez-le au fichier de paramètres MCP de Cline, `~/.cline/data/settings/cline_mcp_settings.json` :

```json
{
  "mcpServers": {
    "pocketalert": {
      "type": "streamableHttp",
      "url": "https://mcp.pocketalert.app/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" },
      "disabled": false,
      "autoApprove": ["create_message"]
    }
  }
}
```

Déclarez `type` explicitement : sans cela, Cline suppose l’ancien transport SSE et la connexion échoue. `autoApprove` permet à Cline d’envoyer une notification sans vous demander votre avis, ce qui est tout l’intérêt lorsque vous êtes absent. Les versions récentes de Cline lisent le même fichier depuis l’extension VS Code, la CLI et JetBrains.

Ajoutez ensuite une instruction dans `.clinerules` :

```text
When you finish a task that took more than a few minutes, call the pocketalert
create_message tool with a one-line summary. Use level "high" if something failed.
```

## Aider

Aider intègre déjà les notifications. Avec `--notifications`, il affiche une notification de bureau (ou fait sonner la cloche du terminal) lorsqu’il attend une saisie, et `--notifications-command` remplace cela par la commande de votre choix. C’est tout ce qu’il faut pour une notification push sur téléphone.

### La commande

Aider exécute la commande via le shell, sans arguments ; le script construit donc le message à partir de ce qu’il peut voir : le répertoire courant est le dépôt sur lequel travaille Aider.

```bash
#!/usr/bin/env bash
project=$(basename "$PWD")

curl -sS --max-time 5 https://api.pocketalert.app/v1/messages \
  -H "Token: $(cat ~/.config/pocketalert/key)" \
  -H 'Content-Type: application/json' \
  -d "{\"title\": \"Aider is waiting · $project\", \"message\": \"Your turn: reply or confirm in the terminal.\"}" \
  >/dev/null 2>&1 || true
```

Enregistrez-le sous `~/.config/pocketalert/aider-notify.sh` puis exécutez `chmod +x` dessus.

Si la [CLI Pocket Alert](/tools/cli) en version 2.0 ou ultérieure est installée et authentifiée, vous pouvez vous passer du script et placer la commande directement dans la configuration ci-dessous :

```yaml
notifications-command: 'pocketalert send -t "Aider is waiting · $(basename "$PWD")" -m "Your turn, reply or confirm in the terminal" -q'
```

Les guillemets simples empêchent YAML de lire le reste de la ligne ; Aider la transmet telle quelle au shell.

### L’activer

Ajoutez deux lignes dans `~/.aider.conf.yml`, ou dans `.aider.conf.yml` à la racine d’un dépôt :

```yaml
notifications: true
notifications-command: ~/.config/pocketalert/aider-notify.sh
```

Ou pour une seule exécution :

```bash
aider --notifications --notifications-command ~/.config/pocketalert/aider-notify.sh
```

### Quand elle se déclenche

Aider envoie une notification par réponse du modèle, dès le premier moment où il attend ensuite votre réponse. En général, il s’agit de l’invite normale qui apparaît après qu’il a fini de modifier les fichiers. Si la première chose dont il a besoin est une confirmation, par exemple « Add file to the chat? » ou « Run shell command? », la notification arrive pour celle-ci, ce qui correspond au cas de « l’attente d’une approbation ». Les confirmations suivantes au sein du même échange n’envoient pas de nouvelle notification.

Aider ne prend pas en charge MCP : la commande de notification est donc la voie à suivre. Elle suffit amplement : Aider attend votre retour après chaque réponse, et c’est précisément le moment où vous voulez être prévenu.

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

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Agent</th><th>Titre</th><th>Corps</th></tr></thead>
<tbody>
<tr><th>Cline</th><td>Cline finished · api</td><td>Les 300 premiers caractères du résultat de Cline</td></tr>
<tr><th>Cline via MCP</th><td>Ce que l’agent rédige</td><td>Un résumé qu’il a choisi d’envoyer</td></tr>
<tr><th>Aider</th><td>Aider is waiting · api</td><td>Your turn: reply or confirm in the terminal.</td></tr>
</tbody>
</table>
</div>

Les messages ont par défaut une priorité normale. Ajoutez `"level": "high"` au JSON si vous voulez qu’ils passent le mode Concentration sur iPhone, ou rendez-les discrets avec `"low"` et consultez l’historique à votre retour.

## Si rien n’arrive

- **Exécutez le script à la main.** Pour Cline : `echo '{}' | ~/Documents/Cline/Hooks/TaskComplete` ; pour Aider : `~/.config/pocketalert/aider-notify.sh`. Pas de notification signifie un problème de clé ou de réseau ; retirez `>/dev/null 2>&1` pour voir la réponse de curl.
- **Vérifiez le nom du fichier.** Cline associe les hooks par leur nom : `TaskComplete` exactement, exécutable, sans `.sh`.
- **Vérifiez la clé de configuration d’Aider.** Utilisez `notifications-command` avec un trait d’union, comme dans l’exemple de configuration d’Aider.

## FAQ

### Ai-je besoin des deux agents ?

Non. Les deux sections sont indépendantes ; configurez celui que vous utilisez.

### Cline ou Aider peuvent-ils voir ma clé API ?

Le hook et la commande de notification lisent la clé depuis un fichier et ne font pas partie de la conversation. La configuration MCP contient la clé afin que Cline puisse se connecter au serveur ; elle n’est pas envoyée au modèle.

### Aider va-t-il me submerger de notifications pendant que je suis devant l’écran ?

Il envoie une notification par réponse. Si c’est trop lorsque vous êtes à votre poste, lancez Aider sans `--notifications` et n’utilisez la configuration que pour les longues sessions, ou ajoutez une vérification en début de script, comme `[ -f ~/.aider-away ] || exit 0`, et créez ce fichier lorsque vous vous absentez.

### Est-ce gratuit ?

Oui. Cline et Aider sont open source, et l’offre gratuite de Pocket Alert couvre 50 messages par jour sur un appareil.

[Obtenir une clé API](/signup), ajoutez le script, et laissez l’agent vous rappeler.
