# Pocket Alert CLI 2.1: niveles, exec, watch y una bandeja en tu terminal

> La CLI de Pocket Alert está reescrita y es de código abierto. Envía con niveles, botones, imágenes y envíos programados, envuelve cualquier comando con exec, convierte líneas de log en notificaciones push con watch y consulta todo en una interfaz de terminal a pantalla completa.

*17.10.2026*

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

La primera CLI de Pocket Alert solo podía enviar un título y un mensaje. Eso bastaba para demostrar la idea, y poco más: sin niveles de prioridad, sin botones, sin envío programado y sin nada para la tarea más común de todas, avisarte cuando termina un comando largo.

La versión 2 es una reescritura. Vive en su propio repositorio bajo la licencia MIT, se instala con un solo comando y cubre todo lo que puede hacer la API. La versión 2.1, publicada hoy, añade `pocketalert ui`: una aplicación de terminal a pantalla completa para tu bandeja, los mensajes programados, las aplicaciones, los dispositivos y los webhooks.

![La bandeja de la CLI de Pocket Alert en la terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-inbox.jpg)

## Instalación

**macOS y 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:** descarga [pocketalert_windows_amd64.zip](https://github.com/PocketAlert/cli/releases/latest/download/pocketalert_windows_amd64.zip) desde la última versión y añade `pocketalert.exe` a tu PATH. Cada versión incluye archivos para macOS y Linux en Intel y ARM, y para Windows en x64, con sumas de comprobación.

Después, inicia sesión una vez con una clave de API desde [Claves de API](/account/apikeys):

```bash
pocketalert auth
```

La clave se introduce en un aviso oculto, se verifica con la API y se guarda en `~/.pocketalert/config.json` con modo `600`. En CI, define `POCKETALERT_API_KEY` en su lugar; tiene prioridad sobre la clave guardada.

## Envía, con todo lo que ofrece la API

La forma básica ahora son dos argumentos:

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

El mensaje puede venir de stdin, así que la salida de un comando llega directamente a tu teléfono:

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

Todo lo demás es un flag:

- **Niveles.** `-l silent|low|default|high|critical`, o `-2` a `2`. `critical` atraviesa No molestar en los planes de pago; los planes gratuitos lo reciben como `high`.
- **Programación.** `--at "2026-10-20 09:50"` en la zona horaria de tu cuenta, o `--in 1d12h`. Hasta 30 días de antelación, en planes de pago. `pocketalert scheduled list` y `scheduled cancel <tid>` gestionan lo que está en cola.
- **Botones de acción.** Hasta tres `--action type:label:value`, donde el tipo es `view`, `http` o `copy`. En planes de pago.
- **Imágenes.** `--image ./screenshot.png` o una URL `https://`. En planes de pago.
- **Destinos.** `-a` para una aplicación, `-d` para un dispositivo.
- **Scripting.** `-q` imprime solo el ID del mensaje, y todos los comandos aceptan `--json` para obtener la respuesta cruda de la API.

Un despliegue fallido con todo a la 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"
```

Un botón `http` envía un POST por defecto. Escribe `http:Ack:GET https://…` para usar otro método, o pasa la forma JSON completa con cabeceras y cuerpo.

## exec: una notificación push cuando termina un comando

Lo que mucha gente escribía como script envoltorio ya viene integrado. `exec` ejecuta un comando, muestra su salida como de costumbre y envía una notificación push al terminar:

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

El título de la notificación es el comando con un ✓, o un ✗ y el código de salida. El cuerpo incluye la duración, el nombre del host y las últimas diez líneas de salida. Los fallos se envían con `high` salvo que definas un nivel, y el código de salida del comando se conserva, así que `exec` es seguro en scripts, cron y CI.

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

`--on` decide cuándo notificar: `always`, `success` o `failure`. `--tail` indica cuántas líneas de salida incluir, o `0` para ninguna.

## watch: líneas de log como notificaciones push

`watch` lee líneas de una tubería y las envía como notificaciones:

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

Las líneas que llegan dentro de la ventana de lote, cinco segundos por defecto, se agrupan en una sola notificación con el número de líneas en el título. Una ráfaga de doscientos errores consume un mensaje de tu límite diario, no doscientos.

## pocketalert ui

Ejecuta `pocketalert ui` y la terminal se convierte en un cliente de Pocket Alert. Cinco pestañas, que se cambian con `tab` o con `1` a `5`: Bandeja, Programados, Aplicaciones, Dispositivos y Webhooks.

La **Bandeja** lista los mensajes con su nivel, aplicación y hora; los no leídos llevan un punto. El panel de la derecha muestra el mensaje seleccionado completo, con sus botones de acción y sus destinos. Busca con `/`, muestra solo los no leídos con `u`, marca uno como leído con `r` o todos con `a`. Los mensajes nuevos aparecen solos mientras la aplicación está abierta.

![Un mensaje con botones de acción en el panel de vista previa](https://cdn.pocketalert.app/blog/pocketalert-cli-2-actions.jpg)

`n` abre el **redactor**: título y mensaje, después aplicación, dispositivo, nivel, hora de envío, imagen y hasta tres botones de acción, cada uno con la misma forma `type:label:value` que los flags de `send`. `ctrl+s` envía. `f` sobre un mensaje existente lo abre de nuevo en el redactor, para reenviarlo o usarlo como plantilla.

![Redactando un mensaje nuevo en la terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-compose.jpg)

Las demás pestañas gestionan el resto de la cuenta. **Aplicaciones** muestra cada una con su nivel por defecto; crea, renombra, cambia el nivel o elimina sin salir del teclado, y pulsa `enter` para ver los mensajes de esa aplicación. **Dispositivos** lista tus teléfonos y permite renombrarlos o eliminarlos. **Webhooks** muestra tus webhooks con su historial de peticiones, y `y` copia la URL de un webhook. **Programados** muestra lo que está en cola y lo cancela con `d`.

![Aplicaciones en la interfaz de terminal](https://cdn.pocketalert.app/blog/pocketalert-cli-2-applications.jpg)

Cada acción destructiva pide confirmación antes, y `?` muestra todos los atajos.

## Gestionar la cuenta desde scripts

También está cubierto el resto de la API, y todos los comandos aceptan `--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"
```

Desde la CLI ahora puedes definir un nivel por defecto en aplicaciones y webhooks, y botones de acción en los webhooks con marcadores `%field.path%` que se rellenan con el payload. Así, una alerta de Grafana puede llegar como `high` con un botón que abre ese panel exacto.

La autocompletación de la shell para zsh, bash y fish viene con `pocketalert completion`.

## Actualizar desde 1.x

Instala la 2.1 con cualquiera de los métodos anteriores; reemplaza el binario antiguo y conserva tu clave guardada. Tres cambios pueden afectar a scripts existentes:

- **El mensaje ya es obligatorio.** `pocketalert send -t "Cron OK"` sin `-m` devuelve un error. Añade un mensaje, pásalo por tubería o usa `exec`, que lo genera por ti.
- **No mezcles las formas.** Usa `send "Title" "Message"` o `send -t "Title" -m "Message"`. `send -t "Title" "Message"` lee el segundo argumento como título y se detiene.
- **Usa `-m` para texto generado.** Un mensaje posicional que empieza por guion, como una lista Markdown de un agente de IA, se lee como opción. `-m "$text"` siempre es seguro.

Los archivos de versión ahora se llaman `pocketalert_<os>_<arch>.tar.gz`, y `.zip` en Windows, si los descargas en un script de aprovisionamiento.

Por el camino se corrigieron varios errores de la 1.x: `webhooks create` ahora respeta `--application` y `--device`, las URL de webhook apuntan al host correcto, los errores van a stderr en lugar de stdout, los títulos no latinos ya no se cortan a mitad de carácter, y al alcanzar el límite diario se muestran tu uso y la hora de reinicio en lugar de un simple `429`.

## Dónde encaja

La CLI es ahora el camino más corto desde una terminal hasta tu teléfono, y las guías de este blog la usan donde ahorra líneas. Para agentes de programación, los scripts de hook de las guías de [Claude Code](/blog/claude-code-push-notifications), [Codex](/blog/codex-notifications) y [Cline y Aider](/blog/cline-aider-notifications) pueden llamar a `pocketalert send` en lugar de curl. Para cron y CI, `exec` sustituye a la mayoría de las líneas `|| curl`.

[Instala la CLI](/tools/cli), ejecuta `pocketalert auth` y prueba `pocketalert ui`.
