# Pocket Alert CLI 2.1: livelli, exec, watch e una inbox nel terminale

> La CLI di Pocket Alert è stata riscritta ed è open source. Invia con livelli, pulsanti, immagini e invii programmati, avvolgi qualsiasi comando con exec, trasforma le righe di log in notifiche push con watch e sfoglia tutto in un'interfaccia a schermo intero nel terminale.

*17.10.2026*

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

La prima CLI di Pocket Alert sapeva inviare un titolo e un messaggio. Bastava per dimostrare l'idea, ma non molto di più: niente livelli di priorità, niente pulsanti, niente invio programmato e niente per il lavoro più comune di tutti, cioè avvisarti quando un comando lungo termina.

La versione 2 è una riscrittura. Vive in un repository dedicato con licenza MIT, si installa con un solo comando e copre tutto ciò che l'API sa fare. La versione 2.1, rilasciata oggi, aggiunge `pocketalert ui`: un'app a schermo intero per la tua inbox, i messaggi programmati, le applicazioni, i dispositivi e i webhook.

![La inbox della CLI di Pocket Alert nel terminale](https://cdn.pocketalert.app/blog/pocketalert-cli-2-inbox.jpg)

## Installazione

**macOS e 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:** scarica [pocketalert_windows_amd64.zip](https://github.com/PocketAlert/cli/releases/latest/download/pocketalert_windows_amd64.zip) dall'ultima release e metti `pocketalert.exe` nel tuo PATH. Ogni release include archivi per macOS e Linux su Intel e ARM e per Windows x64, con checksum.

Poi accedi una volta con una chiave API, che trovi in [Chiavi API](/account/apikeys):

```bash
pocketalert auth
```

La chiave viene inserita in un prompt nascosto, verificata con l'API e salvata in `~/.pocketalert/config.json` con permessi `600`. In CI, imposta invece `POCKETALERT_API_KEY`: ha la precedenza sulla chiave salvata.

## Invia, con tutto ciò che offre l'API

La forma base ora prende due argomenti:

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

Il messaggio può arrivare da stdin, così l'output di un comando va direttamente sul telefono:

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

Tutto il resto si gestisce con i flag:

- **Livelli.** `-l silent|low|default|high|critical`, oppure da `-2` a `2`. `critical` supera Non disturbare sui piani a pagamento; i piani gratuiti lo ricevono come `high`.
- **Programmazione.** `--at "2026-10-20 09:50"` nel fuso orario del tuo account, oppure `--in 1d12h`. Fino a 30 giorni in anticipo, sui piani a pagamento. `pocketalert scheduled list` e `scheduled cancel <tid>` gestiscono ciò che è in coda.
- **Pulsanti di azione.** Fino a tre `--action type:label:value`, dove il tipo è `view`, `http` o `copy`. Sui piani a pagamento.
- **Immagini.** `--image ./screenshot.png` oppure un URL `https://`. Sui piani a pagamento.
- **Destinatari.** `-a` per un'applicazione, `-d` per un singolo dispositivo.
- **Scripting.** `-q` stampa solo l'ID del messaggio, e ogni comando accetta `--json` per la risposta grezza dell'API.

Un deploy fallito con tutto insieme:

```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 pulsante `http` invia una POST per impostazione predefinita. Scrivi `http:Ack:GET https://…` per un altro metodo, oppure passa la forma JSON completa con header e body.

## exec: una notifica push quando un comando termina

Quello per cui molti scrivevano uno script wrapper è ora integrato. `exec` esegue un comando, mostra il suo output come al solito e invia una notifica push al termine:

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

Il titolo della notifica è il comando con un ✓, oppure un ✗ e il codice di uscita. Il corpo riporta la durata, il nome dell'host e le ultime dieci righe di output. Gli errori vengono inviati con livello `high`, salvo diversa impostazione, e il codice di uscita del comando viene restituito, quindi `exec` è sicuro da usare in script, cron e CI.

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

`--on` decide quando notificare: `always`, `success` o `failure`. `--tail` imposta quante righe di output includere, oppure `0` per nessuna.

## watch: righe di log come notifiche push

`watch` legge le righe da una pipe e le invia come notifiche:

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

Le righe che arrivano entro la finestra di raggruppamento, cinque secondi per impostazione predefinita, vengono raccolte in un'unica notifica con il numero di righe nel titolo. Una raffica di duecento errori consuma un messaggio dalla tua quota giornaliera, non duecento.

## pocketalert ui

Esegui `pocketalert ui` e il terminale diventa un client di Pocket Alert. Cinque schede, da cambiare con `tab` oppure con `1` fino a `5`: Inbox, Programmati, Applicazioni, Dispositivi e Webhook.

La scheda **Inbox** elenca i messaggi con livello, applicazione e orario; quelli non letti sono segnati con un puntino. Il riquadro a destra mostra per intero il messaggio selezionato, compresi i pulsanti di azione e i rispettivi destinatari. Cerca con `/`, mostra solo i non letti con `u`, segna come letto uno con `r` oppure tutti con `a`. I nuovi messaggi compaiono da soli mentre l'app è aperta.

![Un messaggio con pulsanti di azione nel riquadro di anteprima](https://cdn.pocketalert.app/blog/pocketalert-cli-2-actions.jpg)

`n` apre il **composer**: titolo e messaggio, poi applicazione, dispositivo, livello, orario di consegna, immagine e fino a tre pulsanti di azione, ciascuno nella stessa forma `type:label:value` dei flag di `send`. `ctrl+s` invia. `f` su un messaggio esistente lo riapre nel composer, per reinviarlo o per usarlo come modello.

![Composizione di un nuovo messaggio nel terminale](https://cdn.pocketalert.app/blog/pocketalert-cli-2-compose.jpg)

Le altre schede gestiscono il resto dell'account. **Applicazioni** mostra ciascuna con il livello predefinito: puoi crearle, rinominarle, cambiarne il livello o eliminarle senza lasciare la tastiera, e premere `enter` per vedere i messaggi di quell'applicazione. **Dispositivi** elenca i tuoi telefoni e ti permette di rinominarli o rimuoverli. **Webhook** elenca i webhook con la cronologia delle richieste, e `y` copia l'URL di un webhook. **Programmati** mostra ciò che è in coda e lo annulla con `d`.

![Applicazioni nell'interfaccia del terminale](https://cdn.pocketalert.app/blog/pocketalert-cli-2-applications.jpg)

Ogni azione distruttiva chiede conferma prima, e `?` mostra tutte le scorciatoie.

## Gestire l'account dagli script

Anche il resto dell'API è coperto, e ogni comando accetta `--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"
```

Dalla CLI ora puoi impostare un livello predefinito per applicazioni e webhook, e pulsanti di azione sui webhook con segnaposto `%field.path%` riempiti dal payload, così un avviso di Grafana può arrivare come `high` con un pulsante che apre proprio quel pannello.

Il completamento della shell per zsh, bash e fish è disponibile con `pocketalert completion`.

## Aggiornare dalla 1.x

Installa la 2.1 con uno dei metodi sopra: sostituisce il vecchio binario e mantiene la chiave salvata. Tre modifiche possono influire sugli script esistenti:

- **Il messaggio ora è obbligatorio.** `pocketalert send -t "Cron OK"` senza `-m` restituisce un errore. Aggiungi un messaggio, passalo da pipe, oppure usa `exec`, che lo genera per te.
- **Non mescolare le forme.** Usa `send "Title" "Message"` oppure `send -t "Title" -m "Message"`. `send -t "Title" "Message"` legge il secondo argomento come titolo e si ferma lì.
- **Preferisci `-m` per i testi generati.** Un messaggio posizionale che inizia con un trattino, come un elenco Markdown prodotto da un agente AI, viene letto come opzione. `-m "$text"` è sempre sicuro.

Gli archivi di release ora si chiamano `pocketalert_<os>_<arch>.tar.gz`, `.zip` su Windows, se li scarichi in uno script di provisioning.

Lungo il percorso sono stati corretti diversi bug della 1.x: `webhooks create` ora rispetta `--application` e `--device`, gli URL dei webhook puntano all'host giusto, gli errori vanno su stderr invece che su stdout, i titoli non latini non vengono più troncati a metà carattere, e raggiungere il limite giornaliero mostra il tuo utilizzo e l'orario di reset invece di un semplice `429`.

## Dove si inserisce

La CLI è ora la strada più breve dal terminale al telefono, e le guide di questo blog la usano dove fa risparmiare righe. Per gli agenti di coding, gli script hook delle guide su [Claude Code](/blog/claude-code-push-notifications), [Codex](/blog/codex-notifications) e [Cline e Aider](/blog/cline-aider-notifications) possono chiamare `pocketalert send` invece di curl. Per cron e CI, `exec` sostituisce la maggior parte dei one-liner `|| curl`.

[Installa la CLI](/tools/cli), esegui `pocketalert auth` e prova `pocketalert ui`.
