# Notificaciones push para Gemini CLI: terminado o esperando aprobación

> Envía una notificación push al teléfono cuando Gemini CLI termina un turno o pide ejecutar una herramienta. Dos hooks en settings.json, un script y el servidor MCP de Pocket Alert.

*15.10.2026*

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

Gemini CLI puede avisarte por su cuenta, pero solo en la terminal: activa `general.enableNotifications` y enviará una notificación de escritorio o un aviso sonoro cuando termine o necesite tu atención. Eso sirve cuando estás frente al ordenador y la terminal está en otra pestaña. No hace nada cuando no estás frente al ordenador.

Los hooks cierran esa brecha. Desde la v0.26 están activados por defecto, y dos de sus eventos son justo para lo que sirve una notificación push en el teléfono:

- **AfterAgent**: Gemini terminó su turno. El payload incluye la respuesta.
- **Notification**: Gemini pide permiso para ejecutar una herramienta.

Esta guía envía ambos a tu teléfono a través de Pocket Alert.

## Una aclaración sobre qué Gemini CLI usar

Desde el 18 de junio de 2026, la documentación de Google indica que Gemini CLI ha sido sustituido por Antigravity CLI en el plan gratuito y en los planes de Google One. Gemini CLI sigue disponible con una clave de API de Gemini de pago, con Vertex AI o con acceso empresarial, y es lo que cubre esta guía. Si usas Antigravity CLI, consulta su documentación para los hooks.

## Lo que necesitas

- Gemini CLI v0.26 o posterior.
- `jq` y `curl`.
- Una cuenta de Pocket Alert, una clave de API desde [Claves de API](/account/apikeys) y la [app](/get-app) en tu teléfono. El plan gratuito es suficiente.

Guarda la clave en un archivo. Gemini CLI puede eliminar las variables de entorno cuyo nombre contenga `KEY` o `TOKEN` antes de ejecutar los hooks, cuando la redacción de variables está activada o cuando se ejecuta en GitHub Actions. Una clave leída desde un archivo no se ve afectada:

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

## Paso 1. El script del hook

Gemini CLI envía a cada hook un objeto JSON por stdin con `hook_event_name` y `cwd`. `AfterAgent` añade `prompt_response`; `Notification` añade `notification_type` y `message`. Guárdalo como `~/.gemini/hooks/pocketalert.sh`:

```bash
#!/usr/bin/env bash
payload=$(cat)
project=$(basename "$(jq -r '.cwd' <<<"$payload")")

case "$(jq -r '.hook_event_name' <<<"$payload")" in
  AfterAgent)
    title="Gemini finished · $project"
    message=$(jq -r '.prompt_response // "Turn complete"' <<<"$payload")
    level=default ;;
  Notification)
    title="Gemini needs approval · $project"
    message=$(jq -r '.message // "Waiting for tool permission"' <<<"$payload")
    level=high ;;
  *) echo '{}'; exit 0 ;;
esac

jq -n --arg t "$title" --arg m "${message:0:300}" --arg l "$level" \
  '{title: $t, message: $m, level: $l}' |
  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 '{}'
```

```bash
chmod +x ~/.gemini/hooks/pocketalert.sh
```

Gemini CLI interpreta la salida estándar de un hook como JSON, así que el script imprime `{}` y nada más; la salida de curl va a `/dev/null`. Un código de salida 2 desde un hook `AfterAgent` rechazaría la respuesta y haría que Gemini la reintentara, por eso el script nunca lo devuelve.

### O con la CLI de Pocket Alert

Si tienes instalada la [CLI de Pocket Alert](/tools/cli) 2.0 o posterior, el bloque de curl se reduce a un solo comando. La CLI escapa el texto por sí misma y toma la clave de `pocketalert auth`, lo que además evita la eliminación de variables descrita arriba:

```bash
pocketalert send -t "$title" -m "${message:0:300}" -l "$level" -q >/dev/null 2>&1 || true
```

Usa `-t` y `-m` en lugar de argumentos posicionales: una respuesta que empiece por un guion, como una lista Markdown, se interpretaría como una opción.

## Paso 2. Registra los hooks

Añade un bloque `hooks` a `~/.gemini/settings.json`, combinado con lo que ya tenga:

```json
{
  "hooks": {
    "AfterAgent": [
      {
        "matcher": "*",
        "hooks": [
          {
            "name": "pocketalert-done",
            "type": "command",
            "command": "/Users/you/.gemini/hooks/pocketalert.sh",
            "timeout": 10000
          }
        ]
      }
    ],
    "Notification": [
      {
        "matcher": "*",
        "hooks": [
          {
            "name": "pocketalert-approval",
            "type": "command",
            "command": "/Users/you/.gemini/hooks/pocketalert.sh",
            "timeout": 10000
          }
        ]
      }
    ]
  }
}
```

Sustituye `/Users/you` por tu directorio personal. Aquí `timeout` se expresa en milisegundos, a diferencia de otros agentes. Para un solo proyecto, pon el mismo bloque en `.gemini/settings.json` dentro del repositorio; Gemini CLI solo ejecuta los hooks de proyecto en una carpeta de confianza.

## Paso 3. Pruébalo

Primero ejecuta el script con un evento de prueba:

```bash
echo '{"hook_event_name":"AfterAgent","cwd":"/tmp/demo","prompt_response":"Hook test"}' \
  | ~/.gemini/hooks/pocketalert.sh
```

Después inicia Gemini CLI y pídele una tarea que termine con una llamada a una herramienta que requiera aprobación, por ejemplo "crea un archivo llamado notes.txt". Mientras espera, recibes **Gemini needs approval**, y **Gemini finished** cuando lo apruebas y el turno termina.

## Lo que llega a tu teléfono

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Evento</th><th>Título</th><th>Cuerpo</th><th>Nivel</th></tr></thead>
<tbody>
<tr><th>Turno terminado</th><td>Gemini finished · api</td><td>Los primeros 300 caracteres de la respuesta</td><td>default</td></tr>
<tr><th>Permiso de herramienta</th><td>Gemini needs approval · api</td><td>El mensaje de permiso de Gemini CLI</td><td>high</td></tr>
</tbody>
</table>
</div>

`high` llega como sensible al tiempo en iPhone, así que las solicitudes de aprobación atraviesan Concentración. Cada push queda guardado en la app y en el panel web.

## O deja que Gemini lo envíe a través de MCP

Con el [servidor MCP de Pocket Alert](/tools/mcp), Gemini puede enviar notificaciones que él mismo redacta, en los momentos que le indiques. Añádelo desde la línea de comandos:

```bash
gemini mcp add --scope user --transport http \
  --header 'Authorization: Bearer $POCKETALERT_API_KEY' \
  pocketalert https://mcp.pocketalert.app/mcp
```

Las comillas simples mantienen `$POCKETALERT_API_KEY` como variable en el archivo de configuración, en lugar de escribir la clave en él. Gemini CLI la expande al conectarse, así que exporta la variable en la shell desde la que inicias `gemini`. Sin `--scope user`, el servidor se añade solo al proyecto actual.

El resultado en `~/.gemini/settings.json`:

```json
{
  "mcpServers": {
    "pocketalert": {
      "url": "https://mcp.pocketalert.app/mcp",
      "type": "http",
      "headers": { "Authorization": "Bearer $POCKETALERT_API_KEY" }
    }
  }
}
```

Ejecuta `/mcp` dentro de Gemini CLI para ver el servidor y sus herramientas. Después, un prompt como "ejecuta la migración y envíame el número de filas cuando termine" acaba con una llamada a `create_message`.

## Si no llega nada

- **Ejecuta el comando de prueba.** Si no llega ningún push, el problema está en la clave o en la red; quita `>/dev/null 2>&1` para ver la respuesta de curl.
- **Comprueba que los hooks están activados.** Lo están por defecto, pero `hooksConfig.enabled: false` en la configuración los desactiva.
- **Revisa la ruta** en `command`: debe ser absoluta y el script debe ser ejecutable.
- **Revisa la salida estándar.** Cualquier cosa que no sea JSON en stdout hace que Gemini CLI ignore el resultado del hook. Asegúrate de que nada más en el script imprima texto.

## Preguntas frecuentes

### ¿En qué se diferencia de `general.enableNotifications`?

Esa opción envía notificaciones de terminal a tu ordenador cuando Gemini te necesita o termina. Los hooks ejecutan cualquier comando, así que pueden llegar a tu teléfono, guardar un historial y usar niveles de prioridad.

### ¿Puedo aprobar la llamada a la herramienta desde el teléfono?

No con este script: te avisa de que Gemini está esperando, y apruebas en la terminal. Un hook `BeforeTool` puede bloquear una llamada a herramienta, así que es posible una puerta de aprobación con un endpoint al que llame tu teléfono; [Notificaciones con intervención humana](/blog/human-in-the-loop-notifications) muestra el patrón.

### ¿Funciona en GitHub Actions?

Sí, y el enfoque del archivo de clave es importante ahí: en GitHub Actions, Gemini CLI elimina del entorno del hook las variables con `KEY` o `TOKEN` en el nombre. Escribe la clave desde un secreto en un archivo en un paso anterior.

### ¿Es gratis?

Los hooks forman parte de Gemini CLI, y el plan gratuito de Pocket Alert cubre 50 mensajes al día en un dispositivo. Gemini en sí necesita una clave de API de pago o acceso empresarial para la CLI, como se indica más arriba.

[Obtén una clave de API](/signup), añade los hooks y deja que Gemini te encuentre cuando te necesite.
