---
title: "Bescheid bekommen, wenn ein langer Terminal-Befehl fertig ist"
description: "Kein Babysitten mehr für einen vierzigminütigen Build. Eine Zeile hinter jedem Befehl schickt das Ergebnis aufs Handy — auch wenn du längst weg bist."
date: 2026-09-09
author: Nooc
authorAvatarLink: /images/avatars/nooc.webp
authorLink: https://nooc.me
tags:
  - Terminal
  - Shell
  - Build-Benachrichtigungen
  - KI-Coding-Agenten
  - Webhook-Benachrichtigungen
---

# Bescheid bekommen, wenn ein langer Terminal-Befehl fertig ist

Du startest einen Trainingslauf, eine komplette Testsuite, ein `docker build` oder einen KI-Coding-Agenten an einer langen Aufgabe. Danach bleiben zwei schlechte Optionen: dasitzen und einen Fortschrittsbalken ansehen, oder weggehen und zwanzig Minuten später feststellen, dass es nach neunzig Sekunden fehlgeschlagen ist.

Es gibt eine dritte Option, und sie passt in eine Zeile.

## Der Einzeiler

Lege in Echobell einen Kanal an, kopiere seine Webhook-URL und häng das an das, was du startest:

```bash
pnpm build; curl -sS -X POST https://hook.echobell.one/t/DEIN_TOKEN \
  -H 'content-type: application/json' \
  -d '{"title":"Build fertig","body":"echobell-web"}'
```

Beachte das `;` und nicht `&&`. Mit `&&` feuert die Mitteilung nur bei Erfolg — und das ist genau verkehrt herum: Der Fehlschlag ist der Fall, von dem du am ehesten hören willst.

## Schick auch den Exit-Code mit

Eine Mitteilung, die „fertig" sagt, erzählt die halbe Geschichte. Fang den Status ein:

```bash
pnpm build; s=$?; curl -sS -X POST https://hook.echobell.one/t/DEIN_TOKEN \
  -H 'content-type: application/json' \
  -d "{\"title\":\"Build $([ $s -eq 0 ] && echo ok || echo FEHLER)\",\"status\":\"$s\"}"
```

`s=$?` muss unmittelbar nach dem Befehl kommen — alles dazwischen, auch der `[`-Test selbst, überschreibt `$?`.

## Mach eine Shell-Funktion daraus

Das jedes Mal zu tippen macht den Zweck zunichte. Pack das in `~/.zshrc` oder `~/.bashrc`:

```bash
notify() {
  "$@"
  local status=$?
  curl -sS -X POST "$ECHOBELL_HOOK" \
    -H 'content-type: application/json' \
    -d "{\"command\":\"$*\",\"status\":\"$status\",\"host\":\"$(hostname -s)\"}" \
    >/dev/null
  return $status
}
```

Setze `ECHOBELL_HOOK` im Shell-Profil — besser noch: halte es ganz aus deinem Dotfiles-Repository heraus und exportiere es aus einer Datei, die du nicht eincheckst. Dann:

```bash
notify pnpm test
notify cargo build --release
notify python train.py
```

Das `return $status` am Ende ist wichtig: Es hält `notify` transparent, sodass `notify make && ./deploy.sh` sich weiterhin so verhält, wie du es erwartest.

Mit diesem Payload können die Kanalvorlagen so aussehen:

**Titel**

```
{{command}} · {{status}}
```

**Text**

```
auf {{host}}
```

## Klingeln nur bei Fehlschlag

Die meisten Läufe gehen gut aus, und davon musst du nichts hören. Zwei Kanäle lösen das sauber: ein normaler für alles und ein Anrufkanal mit einer Bedingung:

```
status != "0"
```

Richte `notify` für alles, wofür du aufstehen würdest, auf den zweiten Kanal — und die erfolgreichen Läufe bleiben still.

## Zugeklapptes Notebook und abgerissene SSH-Sitzung überleben

Läuft der Befehl über SSH, killt das Zuklappen die Shell und die Mitteilung geht nie raus. Zwei Auswege:

**tmux** — starte den Befehl in einer Sitzung und häng dich ab:

```bash
tmux new -d -s build 'notify pnpm build'
```

**nohup** — für den Einzelfall:

```bash
nohup bash -c 'notify pnpm build' >/dev/null 2>&1 &
```

So oder so überlebt der Prozess deine Verbindung, und die Mitteilung kommt an, ob du noch verbunden bist oder nicht.

## KI-Coding-Agenten

Dasselbe Muster deckt einen CLI-Agenten ab, der an einer langen Aufgabe arbeitet:

```bash
notify codex exec "refaktoriere das Zahlungsmodul und lass die Tests laufen"
```

Für Agenten, die mitten im Lauf anhalten und auf einen Menschen warten — eine Freigabe, eine Berechtigungsabfrage — ist eine Fertig-Mitteilung das falsche Werkzeug, denn der Lauf ist nicht fertig. Dieser Fall braucht den Hook oder Callback des Agenten selbst und verdient eher einen Anruf als einen Push. [Freigaben von Agenten in Anrufe verwandeln](/de/blog/ai-agent-human-in-the-loop-alerts) behandelt genau das, inklusive Claude Codes `Notification`-Hook und dessen `agent_needs_input`-Matcher.

Nutze beides: den Hook für „ich hänge fest", die Shell-Funktion für „ich bin fertig".

## Was nicht in die Mitteilung gehört

**Nicht die Befehlsausgabe.** Es ist verlockend, die letzten Zeilen eines fehlgeschlagenen Builds in den Text zu kippen. Lass es: Build-Logs enthalten häufiger Tokens, Verbindungszeichenfolgen und Kundendaten, als man denkt, und ein Mitteilungstext landet auf einem gesperrten Bildschirm. Schick den Exit-Code und schau selbst ins Terminal.

**Nicht die Kanal-URL in ein öffentliches Dotfiles-Repository.** Wer die URL hat, kann in deinen Kanal posten. Halte sie in einer nicht versionierten Datei und schalte **Nur POST** ein, damit eine verirrte Linkvorschau sie nicht auslöst.

## Häufige Fragen

### Warum nicht einfach `terminal-notifier` oder `notify-send`?

Die zeigen eine Mitteilung auf der Maschine, die den Befehl ausführt. Das hilft, solange du davor sitzt. Der Sinn dieses Setups ist der Fall, in dem du das nicht tust: eine entfernte Maschine, ein zugeklapptes Notebook, ein anderer Raum.

### Funktioniert das unter Windows?

Das Muster ja, die Syntax nicht. In PowerShell ist `Invoke-RestMethod -Method Post -Uri $env:ECHOBELL_HOOK -ContentType application/json -Body $json` das Äquivalent, mit `$LASTEXITCODE` statt `$?`.

### Kommt die Mitteilung auf die Uhr?

Ja. Abonnements werden an eine gekoppelte Apple Watch zugestellt, was für „der Build ist durch" ehrlich gesagt das passende Format ist.

### Was, wenn der Befehl 12 Stunden läuft?

In diesem Setup läuft nichts ab — das `curl` startet, wenn der Befehl zurückkehrt. Führ es unter tmux aus, damit eine abgerissene Verbindung den Prozess nicht mitnimmt.

### Können Kolleginnen dieselben Mitteilungen bekommen?

Ja. Teile den Kanal, und jeder Abonnent wählt seinen eigenen Mitteilungstyp. Praktisch auf einer gemeinsam genutzten Trainingsmaschine, auf der mehr als eine Person wissen will, dass die GPU wieder frei ist.

## Fazit

Eine Shell-Funktion, ein Kanal, und eine Bedingung, wenn du nur die Fehlschläge willst. Zwei Minuten Aufwand, und du bekommst die zwanzig zurück, die du vor Fortschrittsbalken verbringst.

[Lade Echobell für iPhone](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=blog-notify-when-terminal-command-finishes-de&mt=8) oder [hole es bei Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid) und probier es an etwas aus, das lange genug dauert, um wegzugehen.

---

## Verwandte Inhalte

- [Freigaben von Agenten in Anrufe verwandeln](/de/blog/ai-agent-human-in-the-loop-alerts)
- [Nie wieder einen GitHub-Actions-Fehler verpassen](/de/blog/github-actions-notifications)
- [Alarme bei fehlgeschlagenen Cron-Jobs](/de/blog/cron-job-failure-alerts)
- [Dokumentation zum Webhook-Auslöser](/de/docs/webhook)
- [Referenz der Kanalbedingungen](/de/docs/conditions)