netwatch v0.27.0
Echtzeit-Netzwerkdiagnose in Ihrem Terminal. Ein Befehl, keine Konfiguration, sofortige Sichtbarkeit.
NetWatch
Sieh, was dein Netzwerk tatsächlich tut — live, in deinem Terminal.
Ein Netzwerk-Monitor, der verschlüsselten Datenverkehr liest, den Prozess hinter jeder Verbindung benennt und Malware beim Heimtelefonieren erwischt. Eine Binärdatei. Null Konfiguration.
Alles auf einmal, mit null Zeilen Chrome — keine Kopfzeile, keine Menüleiste, keine Statusleiste. Download wächst von der gemeinsamen Zeitachse nach oben, Upload von ihr nach unten, sodass Verkehrssymmetrie eine Form ist, die du erkennst, bevor du eine Zahl liest. Farbe kodiert die Größenordnung, nicht die Reihe.
…und das Standard-Instrument mit zehn Tabs darunter, ein V entfernt und mit denselben warmen Collectors — das Dashboard, das Programm hinter jedem Socket, Deep Packet Inspection, die Netzwerkkarte und womit jedes Programm spricht.
Die meisten Netzwerk-Tools beantworten eine Frage — „Was nutzt meine Bandbreite?" — und hören auf. NetWatch geht weiter. Es dekodiert die Protokolle auf der Leitung, sagt dir, welches Programm jede Verbindung geöffnet hat, und achtet auf die Muster, die Ärger bedeuten — einen Portscan, Malware, die zu einem Command-Server funkt, Daten, die über DNS hinausschleichen. Wenn etwas verdächtig aussieht, friert ein Tastendruck ein portables Beweisbündel ein, das du an einen Bugreport anhängen kannst.
Denk daran als eine Null-Konfigurations-Binärdatei, die die Arbeit eines Bandbreitenmessers, der Triage-Ansicht von Wireshark und eines leichten Intrusion-Detektors erledigt — ohne das Terminal zu verlassen.
Es skaliert auf die Frage, die du stellst — in beide Richtungen: --view dense füllt ein großes Terminal mit vier Chrome-freien Boxen, und netwatch --lite ist ein 80×24-Bildschirm für „Was nutzt gerade mein Netzwerk?"; die vollständige Zehn-Tab-Ansicht ist da, wenn die Antwort „etwas, das ich untersuchen muss" ist — einen Tastendruck entfernt, mit derselben Live-Erfassung.
Gebaut für Blue-Teamer, Incident Responder, SREs und Homelab-Betreiber, die sehen müssen, was gerade jetzt passiert — nicht eine Capture-Datei eine Stunde später parsen.
650+ Tests · Landlock-sandboxed (Linux) · parst feindlichen Datenverkehr sicher
Und der Teil, den kein anderes Terminal-Tool überhaupt macht: NetWatch lernt, womit jedes Programm auf der Maschine spricht, macht aus dieser beobachteten Baseline mit einem Tastendruck eine Richtlinie und sagt dir in dem Moment, in dem ein Programm anfängt, mit etwas Neuem zu sprechen.
Beobachten → befördern → warnen. Die Baseline wird mit einem Tastendruck zur Richtlinie; das nächste neue Ziel kommt als Drift an.
Warum NetWatch
- 🔓 Lies verschlüsselten Datenverkehr, den du kontrollierst — richte die
SSLKEYLOGFILEeines Browsers oder einer App auf NetWatch und sieh zu, wie der Klartext seiner TLS-1.3-Sitzungen live dekodiert wird, genauso wie Wireshark es tut. Kein Proxy, keine Zertifikate, nichts in der Mitte. - 🛰️ Erfahre, womit jedes Programm spricht, und werde benachrichtigt, wenn es sich ändert — NetWatch beobachtet, welche Ziele jeder Prozess erreicht (Hostname aus dem ClientHello, autonomes System, Port), und ein Tastendruck befördert diese beobachtete Baseline in eine Egress-Richtlinie. Von da an warnt es, wenn ein Programm anfängt, mit etwas Neuem zu sprechen. Das ist der Satz, den eine Firewall-Regelsatz nicht ausdrücken kann:
curlerreichte früher nurapi.github.com, und heute hat es etwas anderes erreicht. Nur beobachtend — es blockiert nie. - 🧬 Fingerabdruck der Software hinter einer Verbindung — JA4 macht aus jedem TLS/QUIC-Handshake einen stabilen Fingerabdruck, sodass du einen bestimmten Client — oder ein bestimmtes Stück Malware — erkennen kannst, obwohl der Datenverkehr verschlüsselt ist, so wie du einen Browser an seinem User-Agent erkennen würdest. Pivotiere auf einen Fingerabdruck, um jeden anderen Flow derselben Software zu finden.
- 🚨 Erwische Malware beim Heimtelefonieren — eingebaute Erkennung für C2-Beaconing (regelmäßige Check-ins mit geringem Jitter), Portscans und DNS-Tunneling läuft im Hintergrund ohne Einrichtung. Ein kritischer Alarm friert den Recorder automatisch ein, sodass die Beweise bereits gespeichert sind, wenn du hinschaust.
- ⚙️ Benenne den Prozess hinter jeder Verbindung — ordnet jeden Socket dem Programm zu, das ihn geöffnet hat, über
ss/lsof, mit einem optionalen eBPF-Kprobe auf Kernel-Ebene (Linux, dasebpf-Feature), das auch kurzlebige Flows erfasst, die Polling übersehen kann. Funktioniert überall; der Kprobe ist eine Verbesserung, keine Anforderung. - 📡 Dekodiere die Protokolle, nicht nur die Ports — echtes L7-Parsing von TLS, QUIC, HTTP und DNS (plus ein SSH-Banner-/Versions-Sniff) und einem Dutzend weiterer, mit Stream-Tracking pro Flow und Handshake-Timing — sodass du
api.github.comund den JA4-Fingerabdruck siehst, nicht nur „Port 443". - 🎥 Friere die Beweise ein — aktiviere einen rollierenden Recorder und friere jeden Vorfall in ein portables Bündel ein: die Pakete plus die Verbindungen, DNS, Gesundheit und Alarme, die sie erklären. Gebaut für Bugreports und Post-Mortems.
- 🛡️ Sicher von Design — nach der Einrichtung gibt NetWatch seine Privilegien ab und sperrt sich in eine Landlock-Dateisystem-Allowlist (Linux). Ein Tool, das feindlichen Datenverkehr parst, kann deine SSH-Schlüssel, Browserprofile oder
/etc/shadownicht lesen. - 🪟 Skaliert auf einen Bildschirm herunter —
--litebeantwortet „Was nutzt mein Netzwerk, und ist meine Verbindung in Ordnung?" auf einem einzigen 80×24-Bildschirm mit sechs Tasten, sodass es in eine SSH-Sitzung zu einem Pi oder einen tmux-Split passt. Ein Tastendruck eskaliert zur vollständigen Forensik-Ansicht, mit bereits warmen Collectors.
Keine Konfigurationsdateien. Keine Einrichtung. Keine Flags erforderlich.
Installieren```bash
brew install netwatch # macOS / Linux nix-shell -p netwatch # NixOS / Nix paru -S netwatch-tui-bin # Arch (prebuilt; netwatch-tui builds from source) scoop install netwatch # Windows cargo install netwatch-tui # anywhere with Rust
Oder lade ein vorkompiliertes Binary von den [Releases](https://github.com/matthart1983/netwatch/releases/latest) herunter.
**Windows benötigt [Npcap](https://npcap.com/#download) installiert** — die Standardeinstellungen des Installers sind in Ordnung, und ohne Npcap beendet sich NetWatch beim Start mit einem entsprechenden Hinweis. **Build aus dem Quellcode** (`cargo install`, `paru -S netwatch-tui`) benötigt die Entwicklungs-Header von libpcap: `libpcap-dev` auf Debian/Ubuntu und Alpine, `libpcap-devel` auf Fedora/RHEL, `libpcap` auf Arch. Fehlen sie, erscheint beim Linken `cannot find -lpcap`. macOS bringt libpcap mit; die `-static`-Linux-Binaries unten bündeln es und benötigen nichts installiert.
Die Nix-, Arch- und Scoop-Pakete werden von Community-Packagern gepflegt — vielen Dank. Melde
Verpackungsprobleme bei ihnen; melde NetWatch-Fehler hier. Wenn ein Paket hinter einem Release zurückbleibt, zeigt das die
[Repology-Seite](https://repology.org/project/netwatch-tui/versions).
<details>
<summary><strong>Alle Plattformen & Build aus dem Quellcode</strong></summary>
| Plattform | Download |
|----------|----------|
| Linux (x86_64, Debian/Ubuntu) | [`netwatch-linux-x86_64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, Debian/Ubuntu) | [`netwatch-linux-aarch64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (x86_64, statisch — Arch/Fedora/Alpine/jede Distribution) | [`netwatch-linux-x86_64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Linux (aarch64, statisch — Arch/Fedora/Alpine/jede Distribution) | [`netwatch-linux-aarch64-static.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| macOS (Intel) | [`netwatch-macos-x86_64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| macOS (Apple Silicon) | [`netwatch-macos-aarch64.tar.gz`](https://github.com/matthart1983/netwatch/releases/latest) |
| Windows (x86_64) | [`netwatch-windows-x86_64.exe.zip`](https://github.com/matthart1983/netwatch/releases/latest) |
Die `-static`-Linux-Builds bündeln libpcap und haben keine Laufzeitabhängigkeiten — verwende diese auf Arch, Fedora, Alpine oder jeder Distribution, auf der die Standard-Builds `libpcap.so.0.8: cannot open shared object file` melden.
Der Windows-Build erfordert [Npcap](https://npcap.com/#download) — installiere es vor dem ersten Start. Die Standardeinstellungen des Installers sind in Ordnung: NetWatch sucht in `System32\Npcap`, wo Npcap tatsächlich `wpcap.dll` ablegt, daher ist *Install Npcap in WinPcap API-compatible Mode* nicht erforderlich. Ohne Npcap erhältst du eine NetWatch-Meldung, die benennt, was fehlt, keine Windows-Fehlerbox. (Bei v0.29.1 und früher war dieses Kontrollkästchen nötig — siehe [#47](https://github.com/matthart1983/netwatch/issues/47).)
**Aus dem Quellcode:**```bash
git clone https://github.com/matthart1983/netwatch.git && cd netwatch
cargo build --release
Voraussetzungen: Rust 1.70+ und die Entwicklungs-Header von libpcap. Das Gleiche gilt für cargo install netwatch-tui.
| Plattform | Installation |
|---|---|
| Debian / Ubuntu | sudo apt install libpcap-dev |
| Fedora / RHEL | sudo dnf install libpcap-devel |
| Arch | sudo pacman -S libpcap |
| Alpine | sudo apk add libpcap-dev |
| macOS | im System enthalten |
| Windows | Npcap — der Build lädt das Npcap-SDK automatisch herunter, oder setze NPCAP_SDK auf eine entpackte Kopie |
Ohne diese schlägt der Build beim Linken mit /usr/bin/ld: cannot find -lpcap fehl. Wenn du NetWatch nur ausführen und nicht bauen möchtest, benötigen die oben genannten -static-Linux-Binaries nichts davon.
Schnellstart```bash
netwatch # interface stats, connections, config — no privileges needed sudo netwatch # full mode — adds live packet capture + health probes
Das war's. Wechsle die Tabs mit `1`–`9`, drücke `?` für Hilfe, `q` zum Beenden. Das Dashboard ist in fünf Sekunden nützlich; alles darunter ist da, wenn du tiefer eintauchen willst.
> **Linux ohne `sudo`:** erteile die Capture-Fähigkeiten einmal und führe es als dein normaler Benutzer aus —
> `sudo setcap 'cap_net_raw,cap_bpf,cap_perfmon+eip' "$(which netwatch)"`. Führe es nach jedem Upgrade erneut aus ([Details](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#running-without-sudo-linux)).
### Sieh zu, wie es TLS in 60 Sekunden entschlüsselt
Der schnellste Weg zu verstehen, was NetWatch ist — sieh zu, wie es den Klartext einer TLS-1.3-Sitzung liest, die *du* kontrollierst:```bash
sudo netwatch # 1. launch, then open the Packets tab (4)
SSLKEYLOGFILE=/tmp/sslkeylog.txt curl https://example.com # 2. any client that exports its keys
# 3. filter the Packets tab with: decrypted:true
Die entschlüsselten Anwendungsdaten werden inline dargestellt. Ein Keylog-Fehlschlag unterbricht die Erfassung nie — dieser Datensatz bleibt einfach undurchsichtig. (SSLKEYLOGFILE ist derselbe Mechanismus, den Wireshark verwendet; er funktioniert nur für Datenverkehr, den du kontrollierst, niemals für Drittanbieter- oder Malware-Datenverkehr.)
Den Klartext aus einer Live-TLS-1.3-Sitzung lesen — direkt im Terminal entschlüsselt. Kein Proxy, kein Man-in-the-Middle.
Sieh zu, wie es Egress-Drift in 60 Sekunden erkennt
Die Schleife aus der Demo oben, in drei Befehlen:```bash sudo netwatch # 1. launch and open the Egress tab (0). Leave it a minute # while it learns; each process grows a list of destinations # with hostnames, autonomous systems and ports # 2. put the cursor on a process and press Enter — its observed # baseline becomes a rule in egress-policy.toml curl https://example.org # 3. same program, somewhere it has never been
Das neue Ziel landet mit einem `✗ drift`-Urteil und einem Alert. Nichts wurde blockiert — der Punkt ist, dass du *informiert* wurdest.
Die Urteile sind bewusst nicht binär:
| | |
|---|---|
| `✓ sni` / `✓ ip` | Hat einen deklarierten Hostnamen oder eine Adresse getroffen — präzise |
| `~ asn` | Nur über das autonome System getroffen — das lässt *alles zu, was dieser AS betreibt*, was bei einem Hyperscaler praktisch unbegrenzt ist |
| `? ech` | Encrypted ClientHello: Der Name ist absichtlich verborgen, also ist das „nicht beurteilbar", nicht „schlecht" |
| `✗ drift` | Außerhalb der Allowlist |
| `— no rule` | Dieses Programm wurde nie deklariert — es wurde nichts geprüft |
| `✗ undeclared` | Keine Regel, unter `strict = true` — die Richtlinie behauptet vollständig zu sein, also ist die *Abwesenheit* der Befund |
Regeln akzeptieren exakte Hostnamen, `*.wildcards`, autonome Systeme, CIDR-Blöcke (`10.0.0.0/8`) und Ports. `strict = true` ist das, was den Linter von „sag mir, wenn sich meine deklarierte Software danebenbenimmt" in „sag mir, wenn etwas, das ich nie deklariert habe, anfängt zu reden" verwandelt — was die Form eines tatsächlichen Kompromisses ist.
## Was du bekommst
Zehn Tabs, umschaltbar mit `1`–`9` und `0`:
| # | Tab | Was er zeigt |
|---|-----|---------------|
| 1 | **Dashboard** | Schnittstellen, Bandbreitendiagramm, Top-Verbindungen, Gateway/DNS-Status, Latenz-Heatmap. In 5 Sekunden nützlich. |
| 2 | **Connections** | Jeder Socket mit Prozess + PID, Protokoll, Status, GeoIP und Latenz-Sparklines. |
| 3 | **Interfaces** | Pro Schnittstelle IPv4/IPv6, MAC, MTU, RX/TX, Fehler, Drops. |
| 4 | **Packets** | Live-Capture mit echtem L7-Dekodieren, TLS-1.3-Entschlüsselung, JA4, Per-Flow-Stream-Tracking, Filtern, PCAP-Export. |
| 5 | **Stats** | Protokollaufschlüsselung nach Bytes + TCP-Handshake-Zeit-Histogramm. |
| 6 | **Topology** | ASCII-Karte von Maschine → Gateway → DNS → Top-Hosts, mit Traceroute. |
| 7 | **Timeline** | Verbindungs-Timeline, farbcodiert nach TCP-Status; Sicherheitsalerts landen hier. |
| 8 | **Processes** | Pro-Prozess-Bandbreiten-Ranking mit Live-RX/TX und Verbindungszahlen. |
| 9 | **Insights** | *(opt-in)* sendet einen Snapshot an ein lokales/Cloud-LLM für Analyse in Klartext. |
| 0 | **Egress** | Lernt, womit jeder Prozess spricht (Hostname/AS/Port), befördert diese Baseline mit einem Tastendruck zu einer Richtlinie und warnt dann bei Drift. Nur beobachtend, blockiert nie. |
Der Packets-Tab ist, wo die Forensik lebt — tiefes Protokoll-Dekodieren, Live-TLS-1.3-Entschlüsselung, JA4-Threat-Hunting, Wireshark-artige Anzeigefilter und Incident-Capture. **[Siehe die vollständige Funktionsreferenz →](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)**
### Lite-Ansicht
Zehn Tabs sind ein Instrument für Operatoren. Wenn die Frage nur *„was nutzt mein Netzwerk, und ist meine Verbindung in Ordnung?"* ist — eine Maschine, eine SSH-Sitzung zu einem Pi, ein tmux-Split — gibt es `--lite`:```bash
netwatch --lite # one screen, fits 80×24
Ein Bildschirm, sechs Tasten. Live-Durchsatz, Erreichbarkeit und wer spricht – jede Zeile direkt erweitern, während der Eingabe filtern.
Alles auf einem einzigen Bildschirm: Live-Durchsatzdiagramme, Erreichbarkeit von Gateway/DNS/Internet und die aktivsten Teilnehmer nach Prozess und Host. Sechs Tasten – q beenden, p pausieren, / filtern, ↵ einen Teilnehmer erweitern, L zurück zur Gesamtansicht, ? Hilfe.
Drücke L in einer der beiden Ansichten, um zu wechseln. Beide nutzen dieselben Collector, sodass der Wechsel von „irgendetwas sieht seltsam aus" zur vollständigen Forensik-Ansicht mit zehn Tabs nur einen Tastendruck kostet – kein Neustart, kein Verlust des Verlaufs, die Erfassung läuft weiter.
Dichte Ansicht
Die andere Richtung: Wenn du ein großes Terminal hast und alles auf einmal sehen willst, füllt --view dense es mit vier Boxen und ohne Schnickschnack – keine Kopfzeile, keine Menüleiste, keine Statusleiste. Identität, Sortierzustand, Seitenbereich und alle Tastenkürzel leben innerhalb der Boxränder, sodass jede Zeile Daten trägt. Sie benötigt 130×44 als Minimum und wächst in alles hinein, was du ihr gibst: breiter bedeutet mehr Verlauf in den Diagrammen und Platz für vollständige Hostnamen, höher bedeutet mehr Schnittstellen und mehr Verbindungen.```bash
netwatch --view dense # four boxes, needs 130×44
Das ist der Bildschirm oben in dieser README. Das charakteristische Element ist der **gespiegelte Doppelgraph**: Der Download wächst von einer zentralen Zeitachse nach oben, der Upload von derselben Achse nach unten. Verkehrssymmetrie wird zu einer Form, die man erkennt, ohne eine Zahl zu lesen – ein Download-Burst ist eine Klippe über der Linie, ein Backup-Job eine Klippe darunter. Beide Hälften sind Braille bei zwei Samples pro Zeichenzelle, und jede Zelle ist nach ihrer **Höhe im Graphen** eingefärbt und nicht danach, zu welcher Serie sie gehört, sodass man die Schwere eines Spikes sieht, bevor man ihn an der Achse misst.
Durchsatz-Rampen wechseln von kühl zu hell, weil hohe Bandbreite *beschäftigt* ist, nicht *schlecht* – eine gesättigte Leitung während eines Backups arbeitet. Nur begrenzte Werte, bei denen hoch wirklich schlecht ist – Link-Sättigung, Latenzbudget pro Hop – erhalten die Grün→Gelb→Rot-Behandlung, und ihre Messanzeigen färben sich nach Position entlang des Balkens, sodass die rote Zone sichtbar ist, bevor man sie erreicht.
Unter dem Graphen: Raten pro Schnittstelle mit 60-Sekunden-Sparklines, Latenzbudgets über vier Hops (Gateway, DNS, Internet und der langsamste Peer, mit dem du tatsächlich sprichst), und die Verbindungstabelle mit den Details der ausgewählten Zeile, die in den oberen Teil desselben Feldes gehoben werden – kein neuer Bildschirm, kein Zurück-Button. Die Detailzeile trägt den Kernel-TCP-Zustand – `cwnd`, `ssthresh`, `mss`, `rwnd` – direkt aus dem Kernel gelesen: `inet_diag` über Netlink unter Linux, der `net.inet.tcp.pcblist64`-Sysctl unter macOS. Die beiden Kernel sind sich bei den Einheiten uneinig (Linux zählt Segmente, BSD zählt Bytes), daher werden macOS-Werte gegen die MSS normalisiert, und die Spalte bedeutet auf beiden dasselbe. Windows liest `--`, bis `GetPerTcpConnectionEStats` verdrahtet ist.
`V` wechselt durch `full → lite → dense`, oder stelle es einmalig unter **Einstellungen → Ansicht** ein. Unter 130×44 fällt es auf dasselbe 80×24-Raster zurück, das Lite anstrebt – das seinen Bereich ebenfalls füllt – und es scrollt nie seitwärts.
## Tiefergehende Einblicke
| Leitfaden | Was darin steckt |
|-------|--------------|
| **[Funktionsreferenz](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md)** | Jede Tastenkombination, die Anzeigefilter-Sprache, Protokoll-Decoder-Liste, Themes und Konfigurationsoptionen. |
| **[TLS-1.3-Entschlüsselung](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#tls-13-decryption)** | Wie die `SSLKEYLOGFILE`-Entschlüsselung funktioniert, unterstützte Cipher-Suites und was sie lesen kann und was nicht. |
| **[Bedrohungssuche mit JA4](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#threat-hunting-with-ja4)** | Fingerprinting von Clients und Pivotieren über Flows hinweg. |
| **[Sicherheit & die Landlock-Sandbox](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#security--forensics)** | Das Bedrohungsmodell, das Absenken von Capabilities und die Dateisystem-Allowlist. |
| **[Egress-Richtlinien-Linting](https://github.com/matthart1983/netwatch/blob/main/docs/egress-linter-plan.md)** | Das Beobachten → Fördern → Warnen-Modell, die Regelsyntax, der `strict`-Modus und das NDJSON-Exportschema. |
| **[Flight Recorder](https://github.com/matthart1983/netwatch/blob/main/docs/REFERENCE.md#flight-recorder)** | Scharfschalten, Einfrieren und der Inhalt eines Vorfall-Bundles. |
| **[KI-Einblicke](https://github.com/matthart1983/netwatch/blob/main/docs/INSIGHTS.md)** | Optionale lokale/Cloud-LLM-Analyse (standardmäßig deaktiviert). |
## So funktioniert es```
Raw bytes → Ethernet → IPv4/IPv6/ARP → TCP/UDP/ICMP → L7 decoders
↓
Per-flow stream tracking · Handshake timing
TLS 1.3 decryption · JA4 · Threat detection
| Collector | macOS | Linux |
|---|---|---|
| Verbindungen | lsof + PKTAP | /proc/net/tcp + eBPF kprobe |
| Pakete | libpcap (BPF) | libpcap |
| Prozesszuordnung | PKTAP | lsof/ss-Polling, mit optionalem eBPF-kprobe-Overlay |
Alles degradiert elegant: Funktionen, die erhöhte Rechte benötigen, zeigen eine klare Meldung und fallen zurück, stürzen aber nie ab. Vollständige Architekturhinweise finden sich in WIKI.md.
Verwandt
Geschwister: SysWatch (System) und DiskWatch (Festplatte) — gleiche Optik, andere Oberfläche. ESSH — ein reiner Rust-SSH-Client mit derselben TUI-Ästhetik; verbindet dort, wo NetWatch beobachtet.
NetWatch Cloud — gehostetes Fleet-Monitoring für die Server, auf denen du NetWatch ausführst. Ein winziger Rust-Agent auf jedem Linux-Host, ein Echtzeit-Dashboard und E-Mail- sowie Slack-Benachrichtigungen bei Latenz, Paketverlust oder Offline-Hosts. Kostenlos, solange wir wachsen. Der Agent, das SDK und das Dashboard sind MIT-lizenziert; das gehostete Backend ist proprietär.
Danksagung
Paketierer. NetWatch ist in homebrew-core, nixpkgs, dem AUR und dem Scoop-Haupt-Bucket — und ich habe nichts davon paketiert. Jedes davon wurde von jemandem erstellt, der das Tool nützlich fand, die Arbeit unaufgefordert erledigt hat und es seitdem aktuell hält. Der Scoop-Eintrag hat normalerweise ein Release innerhalb von Stunden nach dem Tag verfolgt.
| Dominiquini | netwatch-tui im AUR, seit März 2026 |
| kemelzaidan | netwatch-tui-bin im AUR |
| tomasrivera | netwatch in nixpkgs |
| scillidan | netwatch im Scoop-Haupt-Bucket, seit v0.15.3 |
| Homebrew-Maintainer | für die Aufnahme der Formel in core und den Bot, der seitdem jedes Release verfolgt hat |
Paketierung ist undankbare Arbeit, die nur auffällt, wenn sie bricht. Wenn du NetWatch über einen dieser Wege installierst, hast du ihnen dafür zu danken, nicht mir.
Mitwirkende. @lamchau, @fdncred und @PeteE haben Patches gesendet. Danke — ein Pull Request von einem Fremden ist das Beste, was einem Projekt wie diesem passieren kann.
Und an alle, die ein Issue mit einem echten Reproduktionsfall geöffnet, eine Designentscheidung angefochten oder mir gesagt haben, dass die Ausgabe auf ihrem Terminal falsch war: Das ist die Feedback-Schleife, auf der das aufgebaut ist.
Mitwirken
Fragen, Ideen und Fehlerberichte sind in GitHub Discussions und Issues willkommen. Siehe CONTRIBUTING.md für Codierungskonventionen und WIKI.md für den Architekturleitfaden.
Lizenz
MIT