# Notificações push para Cline e Aider: saiba quando é a sua vez

> Notificações push no celular de dois agentes de programação open-source. O Cline ganha um hook TaskComplete e o servidor MCP do Pocket Alert; o Aider ganha uma linha no .aider.conf.yml.

*16.10.2026*

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

Cline e Aider são os dois agentes de programação open-source que as pessoas mais deixam rodando em segundo plano, e ambos podem executar um comando quando há algo para você ver. Nenhum dos dois envia nada para o seu celular por conta própria. Algumas linhas de configuração resolvem isso.

- **Cline** executa um script de hook quando uma tarefa termina e fala MCP, então também pode enviar notificações que ele mesmo escreve.
- **Aider** executa um comando de notificação quando está esperando sua resposta, depois de uma resposta ou antes de uma confirmação sim/não.

Ambos enviam pelo Pocket Alert, então as notificações chegam no mesmo aplicativo, com o mesmo histórico, dos alertas de tudo o que você roda.

## O que você precisa

- Uma conta no Pocket Alert, uma chave de API em [Chaves de API](/account/apikeys) e o aplicativo no seu celular [iPhone ou Android](/get-app). O plano gratuito é suficiente.
- `curl`, e também `jq` para o hook do Cline.

Guarde a chave em um arquivo. Editores abertos pelo Dock no macOS não leem o perfil do seu shell, então um arquivo é o único lugar que os dois agentes sempre conseguem encontrar:

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

## Cline

### Um hook para tarefas concluídas

Os hooks do Cline são arquivos executáveis com o nome do evento. Coloque um script chamado `TaskComplete`, sem extensão, em `~/Documents/Cline/Hooks/` e o Cline o executa sempre que uma tarefa termina, em qualquer workspace. Para um projeto específico, use `.clinerules/hooks/TaskComplete` dentro do repositório.

O script recebe um objeto JSON pela entrada padrão (stdin). Para `TaskComplete`, os campos importantes são `taskComplete.taskMetadata.result`, a resposta final do Cline, e `workspaceRoots`, as pastas abertas. Também existe um campo `initialTask`, mas a versão atual da extensão o envia vazio:

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

A última linha é a resposta do hook para o Cline: não cancelar, não adicionar nada ao contexto, sem erro. Os hooks têm um limite de 30 segundos, por isso o curl desiste após cinco.

Confirme que os hooks estão ativados: a opção **Hooks** nas configurações de funcionalidades do Cline vem ligada por padrão. Os hooks rodam no macOS e no Linux como scripts de shell; no Windows, o Cline espera um script PowerShell chamado `TaskComplete.ps1`.

### E quando o "Cline está aguardando aprovação"?

A lista de hooks do Cline inclui um evento `Notification` justamente para isso, mas, na versão 4.x atual da extensão, ele está definido e ainda não é chamado. Até lá, não existe um hook confiável para pedidos de aprovação: `PreToolUse` dispara antes de cada ferramenta, inclusive as aprovadas automaticamente. Se você quer se afastar, o caminho prático é ampliar as configurações de aprovação automática do Cline para ações seguras e deixar que `TaskComplete` avise quando o trabalho terminar.

### O servidor MCP

O Cline é um cliente MCP, então também pode enviar notificações pelo [servidor MCP do Pocket Alert](/tools/mcp). Adicione-o ao arquivo de configurações MCP do 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"]
    }
  }
}
```

Defina `type` explicitamente: sem ele, o Cline assume o transporte SSE mais antigo e a conexão falha. `autoApprove` permite que o Cline envie uma notificação sem pedir sua permissão antes, que é justamente o objetivo quando você está longe. Versões recentes do Cline leem o mesmo arquivo na extensão do VS Code, na CLI e no JetBrains.

Depois, adicione uma instrução ao `.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

O Aider tem notificações integradas. Com `--notifications`, ele mostra uma notificação na área de trabalho (ou toca o sino do terminal) quando está esperando sua entrada, e `--notifications-command` substitui isso por qualquer comando que você quiser. Só isso já basta para uma notificação push no celular.

### O comando

O Aider executa o comando pelo shell sem argumentos, então o script monta a mensagem com base no que consegue ver: o diretório atual é o repositório em que o Aider está trabalhando.

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

Salve como `~/.config/pocketalert/aider-notify.sh` e execute `chmod +x` nele.

Com a [CLI do Pocket Alert](/tools/cli) 2.0 ou mais recente instalada e autenticada, você pode dispensar o script e colocar o comando direto na configuração abaixo:

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

As aspas simples impedem que o YAML interprete o restante da linha; o Aider repassa tudo ao shell exatamente como está.

### Ative

Adicione duas linhas em `~/.aider.conf.yml`, ou em `.aider.conf.yml` dentro de um repositório:

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

Ou, para uma única execução:

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

### Quando dispara

O Aider envia uma notificação por resposta do modelo, no primeiro momento em que fica esperando você depois disso. Normalmente é o prompt normal depois que ele termina de editar. Se a primeira coisa que ele precisa é uma confirmação, como "Add file to the chat?" ou "Run shell command?", a notificação chega por causa dela, que é o caso de "aguardando aprovação". Confirmações seguintes na mesma troca não geram outra notificação.

O Aider não tem suporte a MCP, então o comando de notificação é o caminho. Ele também basta: o Aider espera por você após cada resposta, e é exatamente aí que você quer saber.

## O que chega no seu celular

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Agente</th><th>Título</th><th>Corpo</th></tr></thead>
<tbody>
<tr><th>Cline</th><td>Cline finished · api</td><td>Os primeiros 300 caracteres do resultado do Cline</td></tr>
<tr><th>Cline via MCP</th><td>O que o agente escrever</td><td>Um resumo que ele escolheu enviar</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>

As mensagens usam prioridade normal por padrão. Adicione `"level": "high"` ao JSON se quiser que elas passem pelo Foco no iPhone, ou deixe-as silenciosas com `"low"` e confira o histórico quando voltar.

## Se nada chegar

- **Execute o script manualmente.** Para o Cline, `echo '{}' | ~/Documents/Cline/Hooks/TaskComplete`; para o Aider, `~/.config/pocketalert/aider-notify.sh`. Se nenhuma notificação chegar, o problema está na chave ou na rede; remova `>/dev/null 2>&1` para ver a resposta do curl.
- **Confira o nome do arquivo.** O Cline identifica os hooks pelo nome do arquivo: `TaskComplete` exatamente, executável, sem `.sh`.
- **Confira a chave de configuração do Aider.** Use `notifications-command` com hífen, como no exemplo de configuração do Aider.

## Perguntas frequentes

### Preciso dos dois agentes?

Não. As duas seções são independentes; configure apenas a que você usa.

### O Cline ou o Aider conseguem ver minha chave de API?

O hook e o comando de notificação leem a chave de um arquivo e não fazem parte da conversa. A configuração MCP guarda a chave para que o Cline consiga se conectar ao servidor; ela não é enviada ao modelo.

### O Aider vai me bombardear enquanto estou no teclado?

Ele envia uma notificação por resposta. Se isso for demais enquanto você está na mesa, inicie o Aider sem `--notifications` e use o arquivo de configuração só em sessões longas, ou adicione uma verificação no início do script, como `[ -f ~/.aider-away ] || exit 0`, e crie esse arquivo quando sair.

### É grátis?

Sim. Cline e Aider são open source, e o plano gratuito do Pocket Alert cobre 50 mensagens por dia em um dispositivo.

[Gere uma chave de API](/signup), cole o script e deixe o agente avisar você.
