# Pocket Alert CLI 2.1: níveis, exec, watch e uma caixa de entrada no terminal

> A CLI do Pocket Alert foi reescrita e é open source. Envie com níveis, botões, imagens e agendamentos, envolva qualquer comando com exec, transforme linhas de log em notificações push com watch e navegue por tudo numa interface de terminal em tela cheia.

*17.10.2026*

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

A primeira CLI do Pocket Alert só conseguia enviar um título e uma mensagem. Isso bastava para provar a ideia, e pouco mais: sem níveis de prioridade, sem botões, sem agendamento e sem nada para a tarefa mais comum de todas, avisar quando um comando longo termina.

A versão 2 é uma reescrita. Ela fica no próprio repositório, sob a licença MIT, instala com um único comando e cobre tudo o que a API faz. A versão 2.1, lançada hoje, adiciona `pocketalert ui`: um aplicativo de terminal em tela cheia para sua caixa de entrada, envios agendados, aplicativos, dispositivos e webhooks.

![A caixa de entrada da CLI do Pocket Alert no terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-inbox.jpg)

## Instalação

**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:** baixe [pocketalert_windows_amd64.zip](https://github.com/PocketAlert/cli/releases/latest/download/pocketalert_windows_amd64.zip) da última versão e coloque `pocketalert.exe` no seu PATH. Cada versão traz pacotes para macOS e Linux em Intel e ARM, e para Windows em x64, com checksums.

Depois, entre uma vez com uma chave de API obtida em [Chaves de API](/account/apikeys):

```bash
pocketalert auth
```

A chave é digitada em um prompt oculto, validada na API e salva em `~/.pocketalert/config.json` com modo `600`. No CI, defina `POCKETALERT_API_KEY`; ela tem precedência sobre a chave salva.

## Envie, com tudo o que a API oferece

A forma básica agora usa dois argumentos:

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

A mensagem pode vir da entrada padrão (stdin), então a saída de um comando vai direto para o seu celular:

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

Todo o resto é uma flag:

- **Níveis.** `-l silent|low|default|high|critical`, ou `-2` a `2`. `critical` passa pelo Não perturbe nos planos pagos; nos planos gratuitos, é entregue como `high`.
- **Agendamento.** `--at "2026-10-20 09:50"` no fuso horário da sua conta, ou `--in 1d12h`. Até 30 dias à frente, nos planos pagos. `pocketalert scheduled list` e `scheduled cancel <tid>` gerenciam o que está na fila.
- **Botões de ação.** Até três `--action type:label:value`, em que o tipo é `view`, `http` ou `copy`. Nos planos pagos.
- **Imagens.** `--image ./screenshot.png` ou uma URL `https://`. Nos planos pagos.
- **Destinos.** `-a` para um aplicativo, `-d` para um dispositivo.
- **Scripts.** `-q` imprime apenas o ID da mensagem, e todos os comandos aceitam `--json` para a resposta bruta da API.

Um deploy com falha, com tudo de uma vez:

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

Um botão `http` envia um POST por padrão. Escreva `http:Ack:GET https://…` para usar outro método, ou passe a forma JSON completa, com cabeçalhos e corpo.

## exec: uma notificação quando um comando termina

O que a maioria das pessoas fazia com um script de encapsulamento agora vem embutido. `exec` executa um comando, mostra a saída normalmente e envia uma notificação push quando ele termina:

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

O título da notificação é o comando com um ✓, ou um ✗ e o código de saída. O corpo traz a duração, o nome do host e as últimas dez linhas da saída. Falhas são enviadas como `high`, a menos que você defina um nível, e o código de saída do comando é repassado, então `exec` é seguro em scripts, 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` define quando notificar: `always`, `success` ou `failure`. `--tail` define quantas linhas da saída incluir, ou `0` para nenhuma.

## watch: linhas de log como notificações push

`watch` lê linhas de um pipe e as envia como notificações:

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

As linhas que chegam dentro da janela de lote, cinco segundos por padrão, são agrupadas em uma única notificação push, com a contagem de linhas no título. Uma rajada de duzentos erros consome uma mensagem da sua cota diária, não duzentas.

## pocketalert ui

Execute `pocketalert ui` e o terminal vira um cliente do Pocket Alert. São cinco abas, alternadas com `tab` ou de `1` a `5`: Caixa de entrada, Agendadas, Aplicativos, Dispositivos e Webhooks.

A **Caixa de entrada** lista as mensagens com nível, aplicativo e horário, e as não lidas aparecem marcadas com um ponto. O painel à direita mostra a mensagem selecionada por completo, incluindo os botões de ação e seus destinos. Pesquise com `/`, mostre só as não lidas com `u`, marque uma como lida com `r` ou todas com `a`. Novas mensagens aparecem sozinhas enquanto o aplicativo estiver aberto.

![Uma mensagem com botões de ação no painel de visualização](https://cdn.pocketalert.app/blog/pocketalert-cli-2-actions.jpg)

`n` abre o **compositor**: título e mensagem, depois aplicativo, dispositivo, nível, horário de entrega, imagem e até três botões de ação, cada um no mesmo formato `type:label:value` das flags do `send`. `ctrl+s` envia. `f` em uma mensagem existente a abre de novo no compositor, para reenviá-la ou usá-la como modelo.

![Compondo uma nova mensagem no terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-compose.jpg)

As outras abas gerenciam o resto da conta. **Aplicativos** mostra cada um com o nível padrão; crie, renomeie, altere o nível ou exclua sem sair do teclado, e pressione `enter` para ver as mensagens daquele aplicativo. **Dispositivos** lista seus celulares e permite renomear ou remover. **Webhooks** lista seus webhooks com o histórico de requisições, e `y` copia a URL de um webhook. **Agendadas** mostra o que está na fila e cancela com `d`.

![Aplicativos na interface de terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-applications.jpg)

Toda ação destrutiva pede confirmação antes, e `?` mostra todos os atalhos.

## Gerenciando a conta a partir de scripts

O resto da API também está coberto, e todos os comandos aceitam `--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"
```

Pela CLI, agora você pode definir um nível padrão para aplicativos e webhooks, e botões de ação em webhooks com placeholders `%field.path%` preenchidos a partir do payload. Assim, um alerta do Grafana pode chegar como `high` com um botão que abre exatamente aquele painel.

O autocompletar de shell para zsh, bash e fish vem com `pocketalert completion`.

## Atualizando da 1.x

Instale a 2.1 com qualquer um dos métodos acima; ela substitui o binário antigo e mantém a chave salva. Três mudanças podem afetar scripts existentes:

- **Agora a mensagem é obrigatória.** `pocketalert send -t "Cron OK"` sem `-m` retorna erro. Adicione uma mensagem, envie uma pela entrada padrão, ou use `exec`, que gera uma para você.
- **Não misture as formas.** Use `send "Title" "Message"` ou `send -t "Title" -m "Message"`. Já `send -t "Title" "Message"` lê o segundo argumento como título e para aí.
- **Prefira `-m` para textos gerados.** Uma mensagem posicional que começa com hífen, como uma lista Markdown vinda de um agente de IA, é lida como opção. `-m "$text"` é sempre seguro.

Os pacotes de versão agora se chamam `pocketalert_<os>_<arch>.tar.gz`, e `.zip` no Windows, caso você os baixe em um script de provisionamento.

Vários bugs da 1.x foram corrigidos no caminho: `webhooks create` agora respeita `--application` e `--device`, as URLs de webhook apontam para o host certo, os erros vão para stderr em vez de stdout, títulos com caracteres não latinos não são mais cortados no meio de um caractere, e ao atingir o limite diário você vê seu uso e o horário de reset, em vez de um simples `429`.

## Onde ela se encaixa

A CLI agora é o caminho mais curto do terminal para o seu celular, e os guias deste blog a usam onde ela economiza linhas. Para agentes de programação, os scripts de hook dos guias de [Claude Code](/blog/claude-code-push-notifications), [Codex](/blog/codex-notifications) e [Cline e Aider](/blog/cline-aider-notifications) podem chamar `pocketalert send` em vez de curl. Para cron e CI, `exec` substitui a maioria dos one-liners com `|| curl`.

[Instale a CLI](/tools/cli), execute `pocketalert auth` e experimente `pocketalert ui`.
