# Notificări pe iPhone când Claude Code te așteaptă

> O notificare pe iPhone sau pe Apple Watch când Claude Code îți cere permisiunea sau termină o sarcină. Două hookuri Claude Code și CLI-ul honk.

Source: https://honk-honk.app/ro/ghiduri/notificari-claude-code

Claude Code poate lucra singur minute în șir, apoi se oprește: are nevoie de permisiunea ta ca să ruleze o comandă sau a terminat și așteaptă următorul prompt. Dacă ai plecat de la terminal, așteaptă până te întorci.

Claude Code are [hookuri](https://code.claude.com/docs/en/hooks) pentru ambele momente. Un hook `Notification` rulează când are nevoie de permisiunea ta, iar un hook `Stop` rulează când termină un răspuns. Acest ghid le leagă pe amândouă de Honk: iPhone-ul și Apple Watch-ul te anunță, iar o sesiune care te cheamă de zece ori trimite o singură notificare, nu zece.

## Înainte să începi

- Un cont Honk (deocamdată doar pe bază de invitație: [cere acces](https://honk-honk.app/ro/cere-acces)) și un proiect pentru agenții tăi de programare, de exemplu „Claude Code”, cu o cheie API. Dă-i proiectului o cheie doar a lui: oricine o are poate trimite mesaje în proiect, și nicăieri altundeva.
- CLI-ul `honk` pe calculatorul pe care rulează Claude Code: `go install github.com/honk-hq/go/cmd/honk@latest` sau un binar de pe [pagina Releases](https://github.com/honk-hq/go/releases).
- `jq`, care citește JSON-ul pe care Claude Code îl transmite hookurilor. Versiunile recente de macOS îl au deja; pe Linux, îl instalezi din managerul de pachete.

## 1. Ține cheia într-un fișier

Hookurile rulează ca niște comenzi shell, în mediul lui Claude Code. Ca să nu ajungă cheia în fișiere de setări pe care le-ai putea pune într-un commit, pune-o în `~/.config/honk/env`:

```sh
HONK_URL=https://honk-honk.app
HONK_KEY=honk_…
```

Apoi rulează `chmod 600 ~/.config/honk/env`, ca să-l poți citi doar tu.

## 2. Adaugă scriptul pentru hook

Salvează scriptul de mai jos ca `~/.claude/hooks/honk.sh` și fă-l executabil cu `chmod +x`:

```bash
#!/usr/bin/env bash
# A push when Claude Code needs your permission (Notification) or finishes (Stop).
# Claude Code sends the event as JSON on stdin. Every ping from one project
# shares a group key, so Honk folds repeats into one notification.
set -a; . "$HOME/.config/honk/env"; set +a
input=$(cat)
dir=${CLAUDE_PROJECT_DIR:-$(jq -r '.cwd // empty' <<<"$input")}
project=$(basename "${dir:-$PWD}")

case $(jq -r '.hook_event_name' <<<"$input") in
  Notification)
    level=loud
    title="Claude Code needs you in $project"
    text=$(jq -r '.message // empty' <<<"$input") ;;
  Stop)
    level=light
    title="Claude Code finished in $project"
    text=$(jq -r '.last_assistant_message // empty | .[:280]' <<<"$input") ;;
  *) exit 0 ;;
esac

honk send --severity "$level" --title "$title" --message "${text:-$title}" \
  --group-key "claude-code/$project" --source "$(hostname -s)" --quiet || true
```

Scriptul citește evenimentul pe care Claude Code îl trimite pe stdin și îl transformă într-un eveniment Honk:

- **Cere permisiunea:** un Claxon puternic cu titlul „Claude Code needs you in my-app” și cu mesajul lui Claude Code, de exemplu „Claude needs your permission”.
- **A terminat:** un Claxon ușor cu titlul „Claude Code finished in my-app” și cu primele 280 de caractere din ultimul răspuns.

Titlurile sunt chiar în script, deci le poți scrie în română. `|| true` face ca o problemă de rețea să nu devină niciodată o eroare de hook.

## 3. Înregistrează hookurile

Adaugă ambele hookuri în `~/.claude/settings.json`, care se aplică tuturor proiectelor de pe acest calculator. Dacă fișierul are deja o cheie `hooks`, adaugă `Notification` și `Stop` lângă evenimentele care sunt deja acolo:

```json
{
  "hooks": {
    "Notification": [
      {
        "matcher": "permission_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/honk.sh",
            "async": true
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/honk.sh",
            "async": true
          }
        ]
      }
    ]
  }
}
```

- `"matcher": "permission_prompt"` limitează hookul `Notification` la cererile de permisiune. Hookul `Stop` nu primește matcher: rulează la finalul fiecărui răspuns.
- `"async": true` rulează hookul în fundal, așa că Claude Code nu așteaptă niciodată trimiterea notificării.

Același bloc merge și în `.claude/settings.json` dintr-un repository, pe care îl poți pune într-un commit ca să-l împarți cu echipa (fiecare are apoi nevoie de script, de CLI și de propria cheie), sau în `.claude/settings.local.json`, pentru un singur proiect, doar pe calculatorul tău.

Scrie `/hooks` în Claude Code ca să verifici că apar ambele hookuri. Ca să testezi scriptul fără să-l aștepți pe Claude, rulează:

```sh
echo '{"hook_event_name":"Notification","message":"Test from the terminal"}' | ~/.claude/hooks/honk.sh
```

## O notificare pe proiect, nu una la fiecare mesaj

Toate evenimentele unui proiect folosesc cheia de grup `claude-code/<project>`, așa că Honk le ține în același grup. De asta depinde cât de des îți vibrează telefonul:

- Primul mesaj te anunță imediat.
- Cele de după nu mai trimit fiecare câte o notificare. Primești cel mult o actualizare la 5 minute, cu numărul la zi, iar pe iPhone fiecare actualizare o înlocuiește pe cea de dinainte, în loc să se adune.
- Un nivel mai puternic decât tot ce a trimis grupul până atunci ajunge imediat, chiar și în acele 5 minute: de exemplu, o cerere de permisiune (Claxon puternic) după un răspuns terminat (Claxon ușor).

Ambele valori sunt în **Setări**, la proiect. **Cât timp o problemă se repetă, te anunță cel mult o dată la …** schimbă cele 5 minute. După o zi fără mesaje, următorul contează ca nou și te anunță imediat; **Grupează mesajele care vin la mai puțin de … unul de altul** scurtează această pauză, ca fiecare nouă sesiune de lucru să înceapă cu o notificare.

## Mai liniștit: doar când ai plecat de la calculator

Hookul `Stop` rulează după fiecare răspuns, chiar și când stai cu ochii pe terminal. Ca să primești notificări doar când ai plecat, șterge blocul `Stop` și schimbă matcherul în `"permission_prompt|idle_prompt"`. Claude Code trimite `idle_prompt` când a terminat de vreo 60 de secunde și n-ai mai scris nimic de atunci, așa că o notificare înseamnă că te așteaptă cu adevărat.

## Ce arată notificarea

Notificarea arată titlul și mesajul, iar mesajul poate fi începutul răspunsului lui Claude, cu tot cu cod. Pentru proiecte private, deschide **Setări** la proiect și alege la **Ce arată notificările** opțiunea **Generic (fără conținut)**: notificarea arată atunci doar numele proiectului, iar textul rămâne în inbox. Sau scoate complet răspunsul din script.

## Codex

Codex CLI de la OpenAI are un hook mai simplu: `notify` rulează un program după fiecare tură încheiată și îi transmite evenimentul ca un singur argument JSON. Acest script trimite același Claxon ușor, într-un grup separat:

```bash
#!/usr/bin/env bash
# Codex runs this after each finished turn, with the event as one JSON argument.
set -a; . "$HOME/.config/honk/env"; set +a
project=$(basename "$(jq -r '.cwd // "codex"' <<<"$1")")
text=$(jq -r '."last-assistant-message" // empty | .[:280]' <<<"$1")

honk light "Codex finished in $project" "${text:-Done.}" \
  --group-key "codex/$project" --source "$(hostname -s)" --quiet || true
```

Salvează-l ca `~/.codex/honk.sh`, fă-l executabil și adaugă o linie în `~/.codex/config.toml`, cu directorul tău home în cale:

```toml
# a top-level key: put it above the first [section]
notify = ["/Users/you/.codex/honk.sh"]
```

Deocamdată, Codex trimite la `notify` doar turele încheiate (`agent-turn-complete`), așa că scriptul acoperă finalul unei sarcini, nu și cererile de aprobare.