# Notifiche push per Cline e Aider: sappi quando tocca a te

> Notifiche push sul telefono da due agenti di coding open source. Cline usa un hook TaskComplete e il server MCP di Pocket Alert; Aider richiede una sola riga in .aider.conf.yml.

*16.10.2026*

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

Cline e Aider sono i due agenti di coding open source che le persone lasciano più spesso in esecuzione in background, e entrambi possono eseguire un comando quando c'è qualcosa da vedere. Nessuno dei due, da solo, invia nulla al telefono. Bastano poche righe di configurazione per cambiare questo.

- **Cline** esegue uno script hook quando un task è completato e parla MCP, quindi può anche inviare le notifiche push che scrive lui stesso.
- **Aider** esegue un comando di notifica quando attende il tuo input, dopo una risposta o prima di una conferma sì/no.

Entrambi inviano tramite Pocket Alert, quindi le notifiche arrivano nella stessa app, con la stessa cronologia, degli avvisi di tutto il resto che esegui.

## Cosa ti serve

- Un account Pocket Alert, una chiave API da [API Keys](/account/apikeys) e l'app sul tuo [iPhone o Android](/get-app). Il piano gratuito basta.
- `curl`, più `jq` per l'hook di Cline.

Salva la chiave in un file. Gli editor avviati dal Dock su macOS non leggono il profilo della shell, quindi un file è l'unico posto che entrambi gli agenti trovano sempre:

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

## Cline

### Un hook per i task completati

Gli hook di Cline sono file eseguibili con il nome dell'evento. Metti uno script chiamato `TaskComplete`, senza estensione, in `~/Documents/Cline/Hooks/` e Cline lo eseguirà ogni volta che un task termina in qualsiasi workspace. Per un solo progetto, usa invece `.clinerules/hooks/TaskComplete` nel repository.

Lo script riceve un oggetto JSON su stdin. Per `TaskComplete` i campi interessanti sono `taskComplete.taskMetadata.result`, la risposta finale di Cline, e `workspaceRoots`, le cartelle aperte. C'è anche un campo `initialTask`, ma l'estensione attuale lo invia vuoto:

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

L'ultima riga è la risposta dell'hook a Cline: non annullare, non aggiungere nulla al contesto, nessun errore. Gli hook hanno un limite di 30 secondi, per questo curl si ferma dopo cinque.

Assicurati che gli hook siano attivi: l'interruttore **Hooks** nelle impostazioni delle funzionalità di Cline è attivo per impostazione predefinita. Gli hook funzionano su macOS e Linux come script shell; su Windows Cline si aspetta uno script PowerShell chiamato `TaskComplete.ps1`.

### E se "Cline sta aspettando l'approvazione"?

L'elenco degli hook di Cline include un evento `Notification` proprio per questo, ma nell'estensione 4.x attuale è definito e non ancora richiamato. Finché non lo sarà, non esiste un hook affidabile per le richieste di approvazione: `PreToolUse` si attiva prima di ogni strumento, comprese le azioni approvate automaticamente. Se vuoi allontanarti, la strada pratica è ampliare le impostazioni di approvazione automatica di Cline per le azioni sicure e lasciare che sia `TaskComplete` a dirti quando il lavoro è finito.

### Il server MCP

Cline è un client MCP, quindi può anche inviare notifiche push tramite il [server MCP di Pocket Alert](/tools/mcp). Aggiungilo al file delle impostazioni MCP di 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"]
    }
  }
}
```

Imposta `type` esplicitamente: senza, Cline presume il vecchio trasporto SSE e la connessione fallisce. `autoApprove` permette a Cline di inviare una notifica push senza chiederti prima, che è proprio ciò che serve quando sei lontano. Le versioni recenti di Cline leggono lo stesso file dall'estensione per VS Code, dalla CLI e da JetBrains.

Poi aggiungi un'istruzione in `.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 ha le notifiche integrate. Con `--notifications` mostra una notifica desktop (o fa suonare il campanello del terminale) quando attende un input, e `--notifications-command` la sostituisce con qualsiasi comando tu voglia. Per una notifica push sul telefono basta questo.

### Il comando

Aider esegue il comando tramite la shell senza argomenti, quindi lo script costruisce il messaggio da ciò che riesce a vedere: la directory corrente è il repository su cui Aider sta lavorando.

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

Salvalo come `~/.config/pocketalert/aider-notify.sh` e rendilo eseguibile con `chmod +x`.

Se hai installato e autenticato la [CLI di Pocket Alert](/tools/cli) 2.0 o successiva, puoi evitare lo script e inserire il comando direttamente nella configurazione qui sotto:

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

Gli apici singoli impediscono a YAML di interpretare il resto della riga; Aider lo passa alla shell così com'è.

### Attivalo

Aggiungi due righe a `~/.aider.conf.yml`, oppure a `.aider.conf.yml` in un repository:

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

Oppure per una singola esecuzione:

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

### Quando scatta

Aider invia una notifica per ogni risposta del modello, al primo momento in cui ti aspetta dopo di essa. Di solito è il normale prompt dopo che ha finito di modificare il codice. Se la prima cosa di cui ha bisogno è una conferma, come "Add file to the chat?" o "Run shell command?", la notifica arriva per quella, ed è il caso "in attesa di approvazione". Le conferme successive nello stesso scambio non inviano un'altra notifica.

Aider non supporta MCP, quindi il comando di notifica è la strada da seguire. È anche sufficiente: Aider ti aspetta dopo ogni risposta, ed è in quel momento che vuoi saperlo.

## Cosa arriva sul telefono

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Agente</th><th>Titolo</th><th>Corpo</th></tr></thead>
<tbody>
<tr><th>Cline</th><td>Cline finished · api</td><td>I primi 300 caratteri del risultato di Cline</td></tr>
<tr><th>Cline via MCP</th><td>Qualsiasi cosa scriva l'agente</td><td>Un riepilogo che ha scelto di inviare</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>

I messaggi hanno per impostazione predefinita priorità normale. Aggiungi `"level": "high"` al JSON se vuoi che passino la modalità Full immersion su iPhone, oppure mantienili silenziosi con `"low"` e controlla la cronologia quando torni.

## Se non arriva nulla

- **Esegui lo script a mano.** Per Cline, `echo '{}' | ~/Documents/Cline/Hooks/TaskComplete`; per Aider, `~/.config/pocketalert/aider-notify.sh`. Se non arriva la notifica, il problema è la chiave o la rete; rimuovi `>/dev/null 2>&1` per vedere la risposta di curl.
- **Controlla il nome del file.** Cline riconosce gli hook dal nome del file: `TaskComplete` esatto, eseguibile, senza `.sh`.
- **Controlla la chiave di configurazione di Aider.** Usa `notifications-command` con il trattino, come nel file di esempio di Aider.

## FAQ

### Mi servono entrambi gli agenti?

No. Le due sezioni sono indipendenti; configura quello che usi.

### Cline o Aider possono vedere la mia chiave API?

L'hook e il comando di notifica leggono la chiave da un file e non fanno parte della conversazione. La configurazione MCP contiene la chiave perché Cline possa connettersi al server; non viene inviata al modello.

### Aider mi riempirà di notifiche mentre sono alla tastiera?

Invia una notifica push per ogni risposta. Se è troppo mentre sei alla scrivania, avvia Aider senza `--notifications` e usa il file di configurazione solo nelle sessioni lunghe, oppure aggiungi un controllo all'inizio dello script, come `[ -f ~/.aider-away ] || exit 0`, e crea quel file quando ti allontani.

### È gratuito?

Sì. Cline e Aider sono open source, e il piano gratuito di Pocket Alert copre 50 messaggi al giorno su un dispositivo.

[Ottieni una chiave API](/signup), inserisci lo script e lascia che l'agente ti richiami.
