Pin die gewünschte Version fest. Die neueste findest du auf der
[Releases-Seite](https://github.com/kerlenton/mcpsnoop/releases). Jede Eingabe,
was die Exit-Codes bedeuten und wie du es ohne die Action verdrahtest, steht
weiter unten in [The GitHub Action](#the-github-action).

## Schnellstart

Sieh es dir sofort an, ohne etwas einrichten zu müssen.```bash
mcpsnoop demo

Alles nach `--` ist der Befehl, der normalerweise deinen Server startet. Tausche ihn gegen das aus, was du bereits verwendest, wie `python server.py`, `npx -y @scope/server` oder eine kompilierte Binärdatei.

Bei Claude Desktop musst du diese Änderung nicht von Hand vornehmen.```bash
mcpsnoop wrap my-server     # route my-server through mcpsnoop
mcpsnoop unwrap my-server   # put it back

Keine Flags, keine Socket-Pfade, keine Startreihenfolge, die man sich merken muss. Der Shim und die UI finden
sich von selbst, und die UI füllt vergangene Sitzungen von der Festplatte nach.

Für einen streambaren HTTP-Server führen Sie mcpsnoop als Reverse-Proxy aus.```bash
mcpsnoop http --target http://localhost:3000/mcp --listen :7000

Wiederholen Sie `redact-key`, `redact-value` und `redact-path` jeweils in einer eigenen Zeile, um
mehrere Einträge von jeder Art hinzuzufügen.

Das sind alle Schlüssel, die es unterstützt.

Die Datei wird nur im aktuellen Arbeitsverzeichnis gesucht, nicht in übergeordneten
Verzeichnissen.

Explizite Befehlszeilen-Flags überschreiben Werte aus der Konfigurationsdatei.

## Befehle

| Befehl | Funktion |
|---|---|
| `mcpsnoop -- <server>` | einen Stdio-Server als transparenten Shim umschließen |
| `mcpsnoop` | die Live-TUI öffnen |
| `mcpsnoop http --target <url>` | einen Streamable-HTTP-Server proxieren |
| `mcpsnoop export` | eine Sitzung als json, html, text, har oder otlp rendern |
| `mcpsnoop check` | CI bei Fehlern, ungültigen Frames, Warnungen, Routing-Abweichungen, hängenden Aufrufen, verspäteten Ergebnissen oder einem Latenzbudget fehlschlagen lassen |
| `mcpsnoop baseline` | vertrauenswürdige Tool-Definitionen prüfen, akzeptieren oder zurücksetzen |
| `mcpsnoop diff` | Tools und Aufrufe über zwei erfasste Sitzungen hinweg vergleichen |
| `mcpsnoop open` | eine gespeicherte Sitzung in der TUI öffnen |
| `mcpsnoop inventory` | jeden Server auflisten, der auf diesem Rechner über mcpsnoop gelaufen ist |
| `mcpsnoop stats` | alle gespeicherten Erfassungen zu einer Zeile pro Server und Tool zusammenfassen |
| `mcpsnoop prune` | gespeicherte Sitzungsprotokolle löschen, die älter als ein Grenzwert sind |
| `mcpsnoop wrap <server>` | einen der Server von Claude Desktop über mcpsnoop leiten |
| `mcpsnoop unwrap <server>` | den Eintrag dieses Servers wieder in den ursprünglichen Zustand versetzen |
| `mcpsnoop remote <user@host>` | den SSH-Tunnel-Befehl ausgeben |
| `mcpsnoop demo` | eine skriptgesteuerte Sitzung abspielen |

Führen Sie `mcpsnoop help` für die vollständige Liste aus, oder `mcpsnoop help <command>` für die Flags eines einzelnen Befehls.

## Vergleich

| | MCP Inspector | mcpsnoop |
|---|:---:|:---:|
| Sieht Ihren echten Client- und Server-Verkehr | nein | ja |
| Kennzeichnet hängende Aufrufe und Stream-Fehler | nein | ja |
| Kennzeichnet unerwünschte Ausgaben, die den Stream beschädigen | nein | ja |
| Kennzeichnet fehlerhafte JSON-RPC-Frames | nein | ja |
| Erkennt Tool-Definitions-Abweichungen nach der Freigabe | nein | ja |
| Interaktive Terminal-Oberfläche | nein | ja |
| Null-Konfiguration, keine Flags oder Reihenfolge | nein | ja |
| Fähigkeits-Inspektor | teilweise | ja |
| Einen erfassten Aufruf wiedergeben | nein | ja, über Stdio und über HTTP |
| Sitzungsexport (json / html / text / otlp) | nein | ja |
| Einzelne Binärdatei, keine Laufzeitabhängigkeiten | nein | ja |

## Installation

### npm

Keine Go-Toolchain erforderlich. Die meisten MCP-Server sind in Node oder Python geschrieben, daher ist dies
der schnellste Einstieg.```bash
npx mcpsnoop -- node build/index.js

### Homebrew```bash
brew install mcpsnoop

`--older-than` ist erforderlich (es gibt keinen Standardwert, der etwas löschen würde) und
akzeptiert eine Tagesanzahl wie `30d` oder eine Go-Dauer wie `72h`. Tool-Baselines
bleiben unangetastet, da eine Baseline über die Server-Bezeichnung und nicht über die Sitzung
referenziert wird.

Da es direkt in der Pipe sitzt, nicht abseits wie der Inspector, sieht es
genau das, was Ihr echter Client und Server einander sagen, egal in welcher Sprache
der Server geschrieben ist.

## Tastenkombinationen

| Taste | Aktion | | Taste | Aktion |
|---|---|---|---|---|
| `enter` | untersuchen / hineinzoomen | | `/` | filtern |
| `esc` | zurück | | `:` | Befehl |
| `j` / `k` | bewegen | | `r` / `R` | abspielen / bearbeiten und abspielen |
| `g` / `G` | oben / unten | | `c` | Fähigkeiten |
| `ctrl-f` / `ctrl-b` | Seite | | `s` | Tool-Zusammenfassung |
| `p` | pausieren | | `y` | kopieren |
| `shift`+`<Taste>` | nach Spalte sortieren | | `e` | exportieren |
| `ctrl-d` | Sitzung löschen | | `f` | folgen |
| `?` | Hilfe | | | |

Drücken Sie `?` in der App für die vollständige Liste.

## Filtern des Streams

Drücken Sie `/` in einer Sitzung und kombinieren Sie durch Leerzeichen getrennte Tokens, UND-verknüpft. Klartext
stimmt mit Methode, Tool, ID und Payload überein.

| Token | Filtert nach | Beispiel |
|---|---|---|
| `tool:` | Tool-Name | `tool:search` |
| `method:` | JSON-RPC-Methode | `method:tools/call` |
| `id:` | Anfrage-ID und jede Wiederholung, die sie fortsetzt | `id:7` |
| `task:` | Aufgaben-ID | `task:01J...` |
| `dir:` | Richtung (`c2s`, `s2c`) | `dir:s2c` |
| `kind:` | Frame-Typ (`req`, `resp`, `notify`, `stderr`, `invalid`) | `kind:invalid` |
| `status:` | Aufrufergebnis (`ok`, `error`, `cancel`, `late`, `cancelled`, `pending`, `bad`, `warn`, `mismatch` oder ein HTTP-Status wie `401`) | `status:error` |

Stapeln Sie Tokens, um gezielt zu filtern.```text
tool:search status:pending        # in-flight calls to one search tool
status:cancel                     # calls the client gave up on (status:cancelled is a cancelled task)
status:late                       # results that arrived after the cancellation
method:tools/call status:error    # tool calls that failed
dir:s2c kind:req                  # server-initiated requests (servers before 2026-07-28)

| Format | Was du erhältst |
|---|---|
| `json` | korrelierte Aufrufe, Zähler pro Tool sowie p50/p95/p99-Latenz, langsamste Aufrufe, Fähigkeiten und Roh-Frames |
| `html` | eine eigenständige Browserdatei mit Suche und einklappbarem JSON |
| `text` | eine übersichtliche Klartext-Ausgabe |
| `har` | ein Eintrag pro korreliertem Aufruf, in Browser-Devtools und allem anderen, das HAR liest, öffnbar |
| `otlp` | OTLP-JSON mit einem Span pro korreliertem Aufruf, wobei der W3C-Trace-Kontext die Aufrufer-Traces verbindet, sofern vorhanden, und andernfalls ein Trace pro Sitzung |

MCP ist nicht HTTP, daher sind URL, Statuscode und Zeitmessungen eines HAR-Eintrags eine bewusste
Zuordnung jedes Aufrufs und keine Draht-Transkription.

Für OTLP liefert `_meta.traceparent` einer Anfrage die Trace- und Parent-
Span-IDs dieses Aufrufs, und `_meta.tracestate` reist auf dem Span mit. Wenn der Traceparent
fehlt oder ungültig ist, behält mcpsnoop den sitzungsabgeleiteten Trace bei und führt keinen State mit.
mcpsnoop beobachtet, statt teilzunehmen, fügt also keinen eigenen Vendor-Eintrag hinzu
und gibt den State des Aufrufers unverändert weiter.```bash
mcpsnoop export -T html -o out.html                    # an HTML file to open in a browser
mcpsnoop export -T text server.py-48213-7f3a1c9e2b04   # a specific session, as text
mcpsnoop export -T json | jq                           # the newest session, piped to jq
mcpsnoop export -T har -o session.har                  # a HAR file to open in browser devtools
mcpsnoop export -T otlp -o trace.json                  # import into an OTLP-compatible tracing backend

Diese Flags überschreiben die exportierte Datei oder die In-Memory-TUI-Ansicht, niemals das
Quell-JSONL. `export` verweigert eine Ausgabe, die dieselbe Datei wie seine Eingabe benennt,
und schreibt über eine temporäre Datei, die an Ort und Stelle umbenannt wird, sodass ein Lauf,
der fehlschlägt, die vorherige Datei unversehrt lässt.

Das `inputSchema` und `outputSchema` eines Tools, wie sie in einem `tools/list`-
Ergebnis beworben werden, werden von `--redact-key` und `--redact-secrets` aus drei Gründen
in Ruhe gelassen.

- Ein Name innerhalb eines Schemas ist eine Typdeklaration und kein Wert.
- Der Name selbst bleibt so oder so im Log.
- Das Bereinigen des Subschemas unter einer Eigenschaft namens `token` würde die eigenen
  Prüfungen des Tools mitnehmen.

Die Ausnahme gilt nur für diese Position, sodass ein Argument, das zufällig
`inputSchema` heißt, wie jedes andere bereinigt wird, und es stoppt bei `default`,
`const`, `examples` und `enum`, die Daten statt Struktur enthalten. Verwenden Sie
`--redact-path`, um etwas innerhalb eines Schemas zu benennen, oder `--redact-value`, das
Text überall dort abgleicht, wo er sitzt, außer in den beiden Schlüsselwörtern, die mcpsnoop
parst, `type` und `x-mcp-header`.

Was jedes Flag erreicht, unterscheidet sich, also prüfen Sie das Ergebnis, statt es
anzunehmen. Alle vier bereinigen JSON-RPC-Payloads, und `--redact-key`, `--redact-path` und
`--redact-secrets` erreichen nur diese. Nur `--redact-value` bereinigt auch stderr,
anderen Nicht-JSON-Text und das Innere eines Strings. Ein `Mcp-Param-*`-Header wird
zusammen mit dem Body-Wert bereinigt, den er spiegelt. Die übrigen Envelope-Metadaten,
Server-Labels, `Mcp-Name`, `Mcp-Method` und der HTTP-Status, bleiben so
erfasst. Redaktion ist ein Best-Effort-Verfahren, also verwenden Sie einen separaten Ausgabepfad und lesen Sie das
Ergebnis, bevor Sie es teilen.

### Gestreamte abgeschlossene Aufrufe an einen OTLP-Collector senden

Senden Sie Spans, während der Proxy läuft, indem Sie ihn auf einen OTLP/HTTP-JSON-
Traces-Endpunkt ausrichten. Wiederholen Sie `--otlp-header` für Collector-Authentifizierung oder Tenant-
Header.```bash
mcpsnoop \
  --otlp-endpoint http://localhost:4318/v1/traces \
  --otlp-header "Authorization=Bearer $OTLP_TOKEN" \
  -- node build/index.js

mcpsnoop http \
  --target http://localhost:3000/mcp \
  --otlp-endpoint http://localhost:4318/v1/traces

Der Bericht zeigt Tools, die hinzugefügt oder entfernt wurden, Beschreibungs- und `inputSchema`-Änderungen, passende Tool-Aufrufe, deren Status sich geändert hat, sowie bemerkenswerte Laufzeitverschiebungen. Aufrufe werden nach Tool-Name und Argumenten abgeglichen, sodass neu angeordnete Aufrufe weiterhin korrekt verglichen werden. Standardmäßig müssen Laufzeitänderungen um mindestens 100 ms und den Faktor 2 abweichen. Verwenden Sie `--duration-threshold` und `--duration-ratio`, um diese Grenzwerte anzupassen.

Übergeben Sie `--exit-code`, um CI auf Regressionen zu prüfen. Es beendet sich mit einem Nicht-Null-Status, wenn die Nachher-Sitzung:

- ein Tool entfernt
- eine Tool-Beschreibung, einen Titel, ein Eingabeschema, ein Ausgabeschema oder Annotationen ändert
- einen Aufruf enthält, dessen Status schlechter geworden ist
- langsamer wird

Eine Icon-Änderung führt nicht dazu, da sie nur das Erscheinungsbild eines Tools verändert, ohne dessen Funktion zu ändern. Verbesserungen, also hinzugefügte Tools, behobene Aufrufe und Beschleunigungen, führen weiterhin zu einem Null-Status.

## Überprüfen von Sitzungen in CI

Prüfen Sie eine aufgezeichnete Agentenausführung auf Fehler, Stream-Beschädigung, Protokollwarnungen, Routing-Header-Abweichungen, Aufrufe, die nie eine Antwort erhalten haben, verworfene Frames, die die Aufzeichnung unvollständig lassen, Tool-Definitionsabweichungen oder die Verwendung veralteter Protokollfunktionen.```bash
mcpsnoop check [--format text|junit|sarif] [--fail-on error,invalid,warn,mismatch,pending,late-result,drift,deprecated,incomplete,schema] [session-id|log.jsonl|-]

The dropped-frame count travels with the artifacts too, so a capture that
understates itself says so wherever it is opened:

- `missing_frames` in the JSON export
- `log.comment` in HAR
- the `mcpsnoop.session.missing_frames` resource attribute in OTLP```bash
mcpsnoop check build-agent
mcpsnoop check --fail-on error,invalid artifacts/session.jsonl
mcpsnoop check --fail-on mismatch gateway-run.jsonl

### Melde es dort, wo CI bereits hinschaut

`--format junit` schreibt ein `<testcase>` pro Signal und Sitzung, und dessen Fehlschläge
folgen derselben `--fail-on`-Auswahl wie die Textausgabe.```yaml
- name: Check captured MCP session
  run: |
    mkdir -p test-results
    mcpsnoop check --format junit artifacts/session.jsonl > test-results/mcpsnoop.xml
- name: Upload mcpsnoop JUnit report
  if: always()
  uses: actions/upload-artifact@v4
  with:
    name: mcpsnoop-junit
    path: test-results/mcpsnoop.xml

Pinne eine Version an, welche auch immer du möchtest. Die neueste ist auf der
[Releases-Seite](https://github.com/kerlenton/mcpsnoop/releases). Es gibt bewusst
kein schwebendes `v1`. Die angepinnte Version ist auch die Binärdatei, die die
Action installiert, sodass die beiden nie voneinander abweichen können und es keinen
Versionsstandard gibt, der veralten kann.

| Eingabe | |
|---|---|
| `session` | der `.jsonl`-Capture, der geprüft werden soll, relativ zum Repository-Root. Erforderlich |
| `fail-on` | wie `--fail-on`, standardmäßig das, was die CLI standardmäßig verwendet |
| `args` | alle anderen `check`-Flags, wie auf einer Kommandozeile in Anführungszeichen. `--format` wird abgelehnt, da die Action den Bericht liest |
| `upload-sarif` | den Bericht an Code Scanning senden. `true` |
| `category` | der Code-Scanning-Namespace. `mcpsnoop`. Variiere ihn pro Zweig einer Matrix, sonst überschreiben sich die Zweige gegenseitig |
| `fail-on-findings` | den Job bei einem Befund fehlschlagen lassen. `true`. Setze `false`, um die Alerts zu erfassen und die erforderliche Prüfung von Code Scanning entscheiden zu lassen |
| `version` | welche mcpsnoop-Version installiert werden soll. Standardmäßig die Version, die du angepinnt hast |
| `install` | `false`, wenn mcpsnoop bereits im PATH ist, was der Weg auf einer Plattform ist, für die keine Version gebaut wurde |

Ausgaben sind `outcome`, `sarif` und `exit-code`. `outcome` ist `passed`,
`findings` oder `error`, und der dritte Fall sollte separat behandelt werden. Er
bedeutet, dass nichts geprüft wurde, was nicht dasselbe ist wie nichts gefunden zu
haben. **Ein Lauf, der nicht prüfen konnte, schlägt den Job fehl, egal was
`fail-on-findings` sagt**, denn eine Pipeline, die grün wird, obwohl sie nichts
verifiziert hat, ist schlimmer als eine, die fehlschlägt.

Der Job benötigt `security-events: write`, sonst antwortet der Upload mit 403. Setze
`upload-sarif: false` in einem Repository ohne Code Scanning.

### Oder verdrahte es selbst

Die Action besteht aus vier Schritten und keiner Magie. Es von Hand zu tun erfordert
dieselbe Sorgfalt, die es erfordert. Der Upload muss auf den Läufen ausgeführt
werden, die einen Bericht haben, also denjenigen, die mit 0 oder 1 beendet wurden,
und nicht denjenigen, die mit 2 beendet wurden, und der Schritt, der den Job
fehlschlagen lässt, muss danach kommen, sonst erreichen die Befunde nie den Tab,
den sie erreichen sollen.```yaml
permissions:
  # required for all workflows
  security-events: write
  # only required for workflows in private repositories
  actions: read
  contents: read

steps:
- name: Check captured MCP session
  id: check
  run: |
    code=0
    mcpsnoop check --format sarif artifacts/session.jsonl > mcpsnoop.sarif || code=$?
    echo "exit-code=$code" >> "$GITHUB_OUTPUT"
    # 2 means the check never happened, so there is no report to publish and
    # nothing was verified. Stop here rather than uploading an empty file.
    [ "$code" -le 1 ] || exit 1
- name: Upload mcpsnoop SARIF report
  if: ${{ !cancelled() }}
  uses: github/codeql-action/upload-sarif@v4
  with:
    sarif_file: mcpsnoop.sarif
    category: mcpsnoop
- name: Fail on findings
  # Separate, and after the upload, so the findings reach the Security tab on
  # exactly the runs that have some.
  if: ${{ !cancelled() && steps.check.outputs.exit-code == '1' }}
  run: exit 1

In ephemeralen CI startet das Zustandsverzeichnis leer, sodass ein Lauf nichts zum Vergleichen hat und stattdessen die Baseline aufzeichnet, anstatt sie zu verifizieren. **Ein Lauf, der bei Drift fehlschlagen sollte und dann nichts verifiziert hat, besteht nicht** und gibt an, welches Verzeichnis beibehalten werden soll. Das ist der einzige Fall, in dem das Aufzeichnen einer Baseline ein Fehlschlag ist. Ohne `drift` in `--fail-on` ist das Aufzeichnen einer Baseline der normale Ablauf und ändert keinen Exit-Code.

Die Baseline muss also zwischen Läufen überleben, damit ein Drift-Gate eine Bedeutung hat. Zeigen Sie mit `--baseline` auf ein eingechecktes oder zwischengespeichertes Verzeichnis oder setzen Sie `MCPSNOOP_HOME` auf einen dauerhaft gespeicherten Pfad.```
recorded first-seen tool baseline (trusted, not verified)
check failed: drift

`drift` ist für `check` opt-in. Das Standard-Gate `error,invalid,warn` bleibt unverändert.

### Eine Funktion erkennen, die keine der beiden Seiten ausgehandelt hat

SEP-2133 hat optionale Funktionen aus dem Kernprotokoll in Erweiterungen verschoben,
die in der `extensions`-Map der Fähigkeiten jeder Seite beworben werden. Tasks ist eine davon,
also bedeutet am 2026-07-28 ein `tasks/get`, eine `notifications/tasks` oder ein `tools/call`,
das mit einem Task-Handle beantwortet wird, nur dann etwas, wenn die andere Seite gesagt hat, dass sie Tasks spricht.

Wenn das nicht der Fall ist, ist die Spezifikation eindeutig: Die unterstützende Partei MUSS entweder auf das Kernverhalten zurückfallen oder die Anfrage ablehnen. Es trotzdem zu tun, ist der Grund, warum eine Funktion verdrahtet zu sein scheint und dann stillschweigend nichts tut – und was ein Leser stattdessen bekommt, ist ein `-32601` oder ein `-32021` einige Frames später, oder eine Aufgabe, die nie Fortschritte macht. mcpsnoop warnt bei dem Frame, der die Erweiterung erreicht hat, und benennt, welche Seite sie nie beworben hat.```
tool "slow" answered with a task handle uses the io.modelcontextprotocol/tasks
extension, which the client never advertised

Wie `drift` ist auch `deprecated` opt-in. Ein Standardlauf meldet die Anzahl und bleibt
grün, sodass eine Sitzung, die ein weiterhin zulässiges veraltetes Feature nutzt, CI von sich aus nie rot färbt.

### Flag-Schema-Konstrukte, die Clients schlecht verarbeiten

Ein Server kann vollkommen gültig sein und für einen Agenten dennoch schwer zu nutzen sein. Clients
unterscheiden sich darin, wie viel von JSON Schema sie tatsächlich unterstützen, und ein Tool, das das Modell
immer wieder falsch aufruft, ist oft ein Tool, dessen Schema mehr verlangt, als der Client
liefert.

Die Tool-Übersicht, geöffnet mit `s`, hat eine SCHEMA-Spalte, die das Auffälligste
an jedem beworbenen Tool-Schema benennt, mit einem nachgestellten `+`, wenn es mehr als eine
Art gibt.

| Angezeigt | Bedeutung |
|---|---|
| `no root` | die `inputSchema` fehlt, ist kein JSON-Objekt oder hat einen Root-Typ, der nicht `"object"` ist |
| `dialect` | ein `$schema`, das eine andere Dialekt nennt als das 2020-12, auf das die Revision standardmäßig zurückfällt |
| `ext ref` | ein `$ref`, der aus dem Dokument herauszeigt, was auch der Fall ist, vor dem die Spezifikation Implementierer warnt, ihm nicht blind zu folgen |
| `oneOf`, `anyOf`, `allOf`, `not` | ein Kompositions-Keyword, das über Clients hinweg inkonsistent gehandhabt wird |
| `ref` | ein `$ref`, der innerhalb desselben Dokuments zeigt |
| `untyped` | eine Eigenschaft, die keinen Typ und keine andere Möglichkeit deklariert, anzugeben, was sie akzeptiert |

Alle außer der ersten sind Beobachtungen und keine Urteile. Ein Schema, das `oneOf` verwendet,
ist nicht falsch, nur wahrscheinlich von verschiedenen Clients unterschiedlich gelesen, und ein
Schema darf jede Dialekt deklarieren, die es möchte. `no root` ist die Ausnahme: Die
`Tool`-Definition verlangt `inputSchema` und legt ihren Root-Typ auf `"object"` fest, sodass
ein Client, der eine Auflistung validiert, dieses Tool rundweg ablehnt und es nie aufrufbar
wird, ohne dass auf der Leitung etwas erklärt, warum. `no root` führt die Spalte aus
diesem Grund an, und ein Schema, das mcpsnoops eigene Schwärzung bereinigt hat, wird nie gemeldet,
da ein unlesbares Schema kein falsches ist.

Diese Trennung entscheidet, was `check` mit ihnen tut. `no root` ist eine Warnung auf dem
`tools/list`-Frame, sodass es das Standard-Gate `error,invalid,warn` ohne
jedes Flag fehlschlagen lässt, was der Punkt ist: Ein Server, der ein unbrauchbares Tool ausliefert, beantwortet
jeden Handshake normal und erhält schlicht nie einen `tools/call`. Die
Beobachtungen werden als `schema_findings` gezählt und unter `schema
findings:` gemeldet und lassen den Lauf nur fehlschlagen, wenn Sie `schema` zu `--fail-on` hinzufügen. Beide
erreichen `--format junit` und `--format sarif`, und `export` führt die Liste pro Tool
unter `summary.definitions.per_tool[].findings`.```bash
mcpsnoop check session.jsonl                     # a non-object root already fails this
mcpsnoop check --fail-on schema session.jsonl    # and now so do the observations

Ohne `--replay-target` sagt eine HTTP-Sitzung dies aus, statt einen Schlüssel anzubieten, der
nicht funktionieren kann. Mit einem solchen fragt `r` weiterhin vor dem ersten Senden einer Sitzung,
genauso wie ein aufgezeichneter Befehl beantwortet wird, bevor er ausgeführt wird.

Eine Anmeldedaten erreichen den Server über `--replay-header` und sonst nirgendwo.
mcpsnoop zeichnet keinen `Authorization`-Header auf und spielt keinen ab, sodass nichts
erfasst wird, das eine Wiedergabe leaken könnte.

Das wiedergegebene POST trägt, was der Transport vorschreibt, was ein POST des
nackten erfassten Bodys nicht tut: `MCP-Protocol-Version`, ein `Accept`, das sowohl
`application/json` als auch `text/event-stream` auflistet, `Mcp-Method`, `Mcp-Name`, wo die
Spezifikation es verlangt, und jeden erfassten `Mcp-Param-*`. Diese werden wortwörtlich
aus der Erfassung erneut gesendet, Base64-Sentinel und alles, sodass sie nicht mit dem Body
uneins sein können, wie es eine Neuableitung könnte. Der eine Header, der nicht kopiert wird, ist die
Protokollversion, weil der wiedergegebene Body die Revision deklariert, die mcpsnoop spricht, und der
Header zum Body passen muss.

`Mcp-Name` wird aus dem gesendeten Body abgeleitet statt kopiert, weil die
Spezifikation es aus `params.name` oder `params.uri` bezieht und verlangt, dass ein Server
einen Header ablehnt, der mit dem Body uneins ist, sodass eine Bearbeitung, die das Tool
umbenannt, sonst den alten Namen senden würde. Die `Mcp-Param-*`-Header spiegeln die
erfassten Argumente wider, sodass eine bearbeitete Wiedergabe keine davon sendet, statt etwas
über einen Body zu behaupten, den jemand neu geschrieben hat. Eine Erfassung kann nur Header in dieser
einen Familie setzen. Ein Log ist eine Datei, die Leute herumreichen, und wenn man ihm erlaubt, jeden Header zu benennen,
könnte es die Pflicht-Header überschreiben oder eine Anmeldedaten hinzufügen, die niemand übergeben hat.

Ein `Mcp-Param-*`, den eine Redaktionsregel bereinigt hat, stoppt die Wiedergabe mit einem Grund. Das Senden
des Platzhalters würde mcpsnoops eigene Bytes auf einen Live-Server setzen, als hätte ein Benutzer
sie getippt.

Eine Weiterleitung wird verweigert statt befolgt. Die Adresse ist die, die du benannt und
beantwortet hast, und das Befolgen eines 307 würde diese Wahl dem entfernten Ende überlassen, den Body
erneut senden und, bei einem Hop, der nur den Port ändert, auch die Anmeldedaten. mcpsnoop
meldet, wohin der Server es senden wollte, und lässt dich entscheiden, ob du stattdessen
diese benennst.

Eine Antwort, die als einzelnes JSON-Objekt eintrifft, und eine, die als Ereignisstrom
eintrifft, werden beide gelesen, und ein Fehler wird benannt statt nummeriert:

- ein 401 meldet das Schema, das der Server verlangte
- ein `-32020` meldet, woran es etwas auszusetzen hatte
- ein Nicht-JSON-RPC 400 oder 404 sagt, dass die Adresse kein Streamable-HTTP-Endpunkt
  dieser Revision ist

### Die Latenz des Servers von der des Benutzers unterscheiden

Bei Multi-Round-Trip-Anfragen ist ein Tool-Aufruf mehrere Anfragen, und die
Sekunden, die eine Person mit der Beantwortung einer Aufforderung verbracht hat, liegen innerhalb der Spanne. Das ist
bewusst so, da dieses Intervall normalerweise das ist, das du am meisten sehen möchtest, aber es
bedeutet, dass eine Zahl nicht beide Fragen beantworten kann.

Bei einer `book_flight`-Kette, bei der der Server 1,2 Sekunden arbeitete, während der Benutzer 37
brauchte, gibt `check --max-duration 5s` dem Tool die Schuld für 38,2 Sekunden. Es tut das weiterhin,
weil das Ändern der Bedeutung dieses Flags jede Pipeline lockern würde, die es bereits
setzt. Zwei Geschwister benennen stattdessen, was sie messen.```bash
mcpsnoop check --max-server-duration 1s session.jsonl   # the server's share alone
mcpsnoop check --max-round-trips 2 session.jsonl        # how chatty a tool is

## 🛡️ Sicherheitshinweis

**Wichtig:** Dieses Tool ist ausschließlich für autorisierte Sicherheitstests und Bildungszwecke gedacht. Der Autor übernimmt keinerlei Verantwortung für Missbrauch oder Schäden, die durch die Verwendung dieses Tools entstehen. Stelle sicher, dass du die geltenden Gesetze und Vorschriften einhältst, bevor du dieses Tool verwendest.

## 📜 Lizenz

Dieses Projekt ist unter der [MIT-Lizenz](https://github.com/kerlenton/mcpsnoop/blob/main/LICENSE) lizenziert – Details findest du in der [LIZENZ](https://github.com/kerlenton/mcpsnoop/blob/main/LICENSE)-Datei.

## 🙏 Danksagungen

- Besonderer Dank geht an die Open-Source-Community für ihre kontinuierliche Unterstützung und Beiträge.
- Inspiriert von verschiedenen Open-Source-Sicherheitsprojekten und -Forschungsergebnissen.

## 📧 Kontakt

Bei Fragen, Vorschlägen oder Feedback kannst du dich gerne an uns wenden:

- **E-Mail:** [[email protected]](mailto:[email protected])
- **GitHub Issues:** [Projekt-Repository](https://github.com/example/security-tool/issues)

## 🚀 Schnellstart

### Voraussetzungen

- Python 3.8 oder höher
- pip (Python-Paketmanager)
- Grundkenntnisse in Netzwerksicherheit

### Installation

```bash
git clone https://github.com/example/security-tool.git
cd security-tool
pip install -r requirements.txt

python security_tool.py --target example.com --scan-type full

python security_tool.py --target example.com --scan-type quick

python security_tool.py --target example.com --scan-type full --output report.html

# Beispiel-Plugin
class CustomPlugin:
    def __init__(self):
        self.name = "Benutzerdefiniertes Plugin"
    
    def run(self, target):
        # Plugin-Logik hier
        return {"status": "erfolgreich"}

import requests

# Beispiel-API-Aufruf
response = requests.get("https://api.example.com/v1/scan", params={"target": "example.com"})
print(response.json())

pip install -r requirements.txt

sudo python security_tool.py --target example.com

assertion failed: 1 tool call exceeded the 1s server budget (worst: tool "book_flight" held for 1.2s)
assertion failed: 1 tool call exceeded the 2 round trip budget (worst: tool "book_flight" took 3)
```
Beide sind standardmäßig deaktiviert, sodass ein Standard-`check`-Lauf unbeeinflusst bleibt, und beide werden aus Frame-Zeitstempeln und einem Link ausgelesen, den mcpsnoop bereits abgeleitet hat, sodass keiner über Absichten rät.

Drücken Sie `i` in der TUI für die Aufschlüsselung oder lesen Sie `interactions` in den JSON-, Text- und HTML-Exporten. Jeder Eintrag ist eine logische Operation mit ihrer Round-Trip-Anzahl, ihrer Gesamtdauer, dem Anteil, den der Server hielt, und dem Anteil, den sie auf den Client wartete, plus einer Zeile pro Hop, die benennt, wonach jede Antwort fragte. Die Zusammenfassung pro Tool erhält eine `TRIPS`-Spalte, sodass ein gesprächiges Tool sichtbar ist, ohne etwas zu öffnen.

`export --format har` legt den Serveranteil in `wait` und den Rest in `blocked`, wofür dieses Feld gedacht ist, sodass ein Viewer aufhört, eine 38-Sekunden-Serverwartezeit zu zeichnen, die nie stattfand.

Die Zählungen und die beiden Anteile werden akkumuliert, wenn Frames eintreffen, und nicht abgeleitet, wenn Sie danach fragen, weil der Live-Speicher alte Frames freigibt, um innerhalb seines Budgets zu bleiben, und eine abgeleitete Antwort stillschweigend ein Fenster statt einer Kette wäre. Die Aufschlüsselung pro Hop wird aus den noch gehaltenen Frames gelesen und sagt dies, wenn sie nur Teil einer Kette ist. `ServerTime + ClientTurnaround` ergibt die Gesamtdauer konstruktionsbedingt und nicht durch Arithmetik, der jemand vertrauen muss.

`--max-round-trips` beurteilt eine Kette, die noch läuft, weil jede Anfrage, die sie bereits gestellt hat, zählbar ist und ein Server, der immer wieder fragt, genau die Operation erzeugt, die niemand je abschließt. `--max-server-duration` wartet auf ein Ende, was die Regel ist, die `--max-duration` bereits anwendet, da eine noch offene Operation keine Latenz zu beurteilen hat.

Eine Operation, die mcpsnoop nicht verknüpfen konnte, bleibt ihr eigener Einzel-Hop-Eintrag. `matchRetry` verweigert absichtlich eine mehrdeutige Verknüpfung, und diese Ansicht füllt diese Lücke nicht.

Eine Operation, die eine Anfrage benötigte, trägt keine Hop-Aufschlüsselung, weil ein einzelner Hop die Gesamtdaten darüber wortwörtlich wiederholt. Eine Kette meldet einen Hop pro Anfrage und sagt dies, wenn der Speicher nicht mehr jeden Frame hält oder wenn Arbeit sich außerhalb des Anfrage-Antwort-Paars abspielt, aus dem ein Hop besteht, was ein Task-Handle tut.

### Sehen, was ein Server Ihren Benutzer gefragt hat

Elicitation ist der eine Pfad in MCP, bei dem eine Person Daten in einen Server eingibt, und unter MRTR sind Frage und Antwort nicht länger zwei Hälften eines Austauschs. Die Frage ist in einem `InputRequiredResult` vergraben, die Antwort kommt in `inputResponses` bei einem Retry unter einer anderen ID zurück, und das Einzige, was sie verbindet, ist der Link, den mcpsnoop bereits ableitet.

Ohne diese Paarung liest sich eine abgelehnte Passwortanfrage wie ein einfacher Tool-Fehler.```
tools/call login_legacy [form] creds: decline after 3s
  password string
```
Drücke `l` in der TUI oder lies `elicitations` in den JSON-, Text- und HTML-Exporten.
Jede Zeile nennt die Operation, die die Frage unterbrochen hat, den Modus, die Nachricht,
was gefragt wurde, was der Benutzer getan hat und wie lange er gebraucht hat. Eine Frage, die
kein Retry je beantwortet hat, wird als ausstehend angezeigt, was MRTR zu einem normalen
Ergebnis macht und nicht zu einem Fehler, da die Spezifikation Servern vorschreibt, nicht
anzunehmen, dass ein Client überhaupt erneut versucht.

Formularzeilen listen die Eigenschaftsnamen von `requestedSchema` und ihre deklarierten Typen auf. Eine
Eigenschaft, deren Subschema eine Redaktionsregel ersetzt hat, zeigt einen unbekannten Typ anstelle des
Platzhalters, weil ein Platzhalter nichts ist, was der Server deklariert hat. URL-Zeilen tragen die Adresse
vollständig, die die Spezifikation einem Client vor der Zustimmung anzeigen lässt, und nennen den Host
einzeln, den sie gegen Subdomain-Spoofing hervorheben soll.

Das Ledger trägt nie einen übermittelten Wert. Was ein Benutzer getippt hat, bleibt in der
Erfassung für den, der es braucht, und es aus einer Zusammenfassungsoberfläche herauszulassen, die
zum Exportieren und Weiterreichen gebaut wurde, hält das vollständig aus der Redaktionsgeschichte
heraus. Am wichtigsten ist das im URL-Modus, wo die Spezifikation Anmeldedaten absichtlich platziert.

Ein Retry beantwortet die Runde, aus der er ausgestellt wurde, und keine andere. MRTR teilt einem Server
mit, dass er, wenn ein Client einen Teil des Gefragten weglässt, in einer neuen Runde erneut fragen
soll, sodass eine frühere Runde mit einem unbeantworteten Schlüssel neben einem beantworteten
normaler Verkehr ist und die unbeantwortete Hälfte ausstehend bleibt, statt sich die Antwort der
späteren Runde zu borgen.

Eine aufgezeichnete Frage ist begrenzt. Die Nachricht, die URL und die Feldliste werden für die
Lebensdauer der Sitzung gehalten, außerhalb des Frame-Budgets, das Bodies freigibt,
sodass ein Server keine beliebig teure Frage stellen kann. Die Grenzen liegen weit über jeder
echten Frage, und eine abgeschnittene Nachricht sagt, dass sie abgeschnitten wurde.

Nichts hier warnt und nichts hier ändert einen `check`-Exit-Code. Ein Ledger
zeichnet auf, was passiert ist. Es bewertet es nicht.

### Finde das Tool, das bei jedem vierten Lauf versagt

`check` liest eine Sitzung und `diff` liest genau zwei, sodass ein Tool, das
gelegentlich versagt, unsichtbar bleibt, bis jemand die Erfassungen von Hand öffnet. Über
sechzehn Erfassungen eines Servers, dessen `run_query` etwa ein Viertel der Zeit
`isError` beantwortet, meldet `check` die neueste, ehrlich, als sauber.```bash
mcpsnoop stats
mcpsnoop stats --since 7d --label prod
mcpsnoop stats --limit 20 --format json
```
```
## 🛡️ Sicherheitshinweis

**Wichtig:** Dieses Tool ist ausschließlich für autorisierte Sicherheitstests und Bildungszwecke gedacht. Die unbefugte Nutzung dieses Tools gegen Systeme, die Ihnen nicht gehören oder für die Sie keine ausdrückliche schriftliche Genehmigung haben, ist illegal und unethisch. Der Autor übernimmt keinerlei Verantwortung für Missbrauch oder Schäden, die durch die Verwendung dieses Tools entstehen. Sie sind allein für die Einhaltung aller geltenden Gesetze und Vorschriften verantwortlich.

## 📦 Installation

```bash
git clone https://github.com/example/repo.git
cd repo
pip install -r requirements.txt
```

## 🚀 Schnellstart

```bash
python main.py --target example.com --output results.txt
```

## ⚙️ Konfiguration

Die Konfiguration erfolgt über eine YAML-Datei:

```yaml
target: example.com
threads: 10
timeout: 30
output: results.txt
```

## 🧩 Verwendung als Modul

```python
from tool import Scanner

scanner = Scanner(target="example.com")
results = scanner.run()
print(results)
```

## 📚 Dokumentation

Ausführliche Dokumentation finden Sie im [Wiki](https://github.com/example/repo/wiki).

## 🤝 Beiträge

Beiträge sind willkommen! Bitte lesen Sie die [CONTRIBUTING.md](https://github.com/kerlenton/mcpsnoop/blob/main/CONTRIBUTING.md) für Details zum Einreichen von Pull Requests.

## 📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – siehe die Datei [LICENSE](https://github.com/kerlenton/mcpsnoop/blob/main/LICENSE) für Details.

## 🙏 Danksagungen

- Allen Mitwirkenden und Unterstützern dieses Projekts.
- Der Open-Source-Community für ihre kontinuierliche Unterstützung.

`ERR` und `PROTO` sind separate Spalten, weil die Spezifikation sie zu
getrennten Dingen macht. Ein Tool, das `isError` beantwortet, meldet etwas, auf das ein
Modell reagieren und es erneut versuchen kann. Ein JSON-RPC-Fehler bedeutet, dass die Anfrage oder der Server falsch ist.
`SESS` ist die Anzahl der Sitzungen, die einen Fehler sahen, über die Sitzungen, die das
Tool aufriefen – das ist die Frage „ein Lauf von zehn“, die eine Rate über Aufrufe nicht
beantworten kann.

Zeilen sind gemeinsam nach Server und Label verschlüsselt. Der Server ist der aufgezeichnete
Befehl und das Arbeitsverzeichnis für stdio und der Endpunkt für HTTP, dieselbe
Identität, die `inventory` verwendet. Jede Hälfte allein bündelt etwas, das sie nicht sollte: das
Label allein vermischt zwei Server, die einen Namen ableiten, was immer dann passiert, wenn
zwei Checkouts eines Projekts denselben Einstiegspunkt ausführen, und die Identität allein vermischt einen
Befehl, der absichtlich als `prod` und erneut als `staging` ausgeführt wird. Beide Fehler
verschmieren zwei saubere Verteilungen zu einer, die keines von beiden beschreibt.

Wenn zwei Zeilen sich ein Label teilen, trägt die Zelle `SERVER` das Arbeitsverzeichnis
oder den Endpunkt, der sie unterscheidet, und das JSON trägt `command`, `cwd` und
`endpoint` in jeder Zeile. Ein Name, der nie mehrdeutig war, bleibt unverändert, sodass die
gewöhnliche Tabelle unverändert ist.

Jede Sitzung in einem Log wird eingefaltet, nicht nur die erste, sodass eine Datei, die durch
Verkettung von Captures entsteht, alle zählt.

Perzentile werden über die rohen Dauern gepoolt. Ein Median von Medianen ist ein Median
von nichts. Eine Operation mit mehreren Round-Trips ist ein Aufruf mit einer Dauer, egal wie
viele Anfragen sie benötigte, und ein noch offener Aufruf zählt zu `CALLS`, während er
keine Latenz beiträgt.

Ein Capture ist jeweils resident. Ein Log wird geladen, in die laufenden
Zähler eingefaltet und verworfen, bevor das nächste geöffnet wird, sodass ein Verzeichnis mit Hunderten
das größte einzelne Capture kostet und nicht deren Summe.

`--limit` standardmäßig auf hundert der neuesten Logs, und der Kopf sagt, wie viele von wie
vielen gelesen wurden, sodass eine begrenzte Antwort nie für eine vollständige durchgeht.
`stats` berichtet und sperrt nicht: Es schreibt nichts, berührt keine Baseline, öffnet
keinen Socket und beendet mit 0, wann immer der Durchlauf erfolgreich war.

### Sehen, welche Server hier tatsächlich gelaufen sind

Die Erkenntnis, die Leute über Shadow MCP ständig wiederholen, ist, dass Organisationen
mehrere Male mehr laufende MCP-Server entdecken, als irgendjemand genehmigt hat, weil ein
Server oft nur eine Abhängigkeit ist, die jemand einem IDE-Plugin hinzugefügt hat. Dasselbe
passiert im Kleinen auf einem einzelnen Laptop, und mcpsnoop hat die Antwort die ganze Zeit
aufgezeichnet, ohne sie je zu zeigen.```bash
mcpsnoop inventory
mcpsnoop inventory --tools          # also count what each server last advertised
mcpsnoop inventory --format json    # for something else to read

### Sehen Sie, was der Server Sie im Kontext kostet

Tool-Definitionen gelangen bei jeder Konversation in den Kontext des Modells, und Tool-Ergebnisse bei jedem Aufruf. Die Tool-Zusammenfassung (`s`) misst beides aus der Sitzung, die Sie tatsächlich erfasst haben.

Die Zeile `definitions` ist die feste Kosten: wie viel das `tools/list` dieses Servers wiegt, bevor ein einziger Aufruf getätigt wird. Die Spalte `DEF` schlüsselt das pro Tool auf, und `RESULT` zeigt, was die Antworten jedes Tools bisher gekostet haben. Die Tabelle bleibt nach Fehlern und Latenz sortiert, also überfliegen Sie `DEF`, um die teuren Definitionen zu finden. Der Export listet sie zuerst nach Gewicht. Eine Zeile unter der Tabelle nennt das einzelne schwerste Ergebnis, das eine Gesamtsumme verdeckt.

Die Definitionszahlen sind das JSON ohne unbedeutende Leerzeichen, sodass ein Server, der sein `tools/list` hübsch formatiert ausgibt, nicht als teurer gezählt wird als einer, der das nicht tut, und derselbe Server misst über Erfassungen hinweg gleich. `RESULT` sind die Bytes, wie sie ankamen: Ein Ergebnis ist eine einmalige Nutzlast und kein Vertrag, der eine Normalisierung wert wäre.```bash
mcpsnoop export -T json | jq '.summary.definitions'

Der Socket liegt im Statusverzeichnis des entfernten Systems, aufgelöst als `MCPSNOOP_HOME`,
sonst `XDG_STATE_HOME/mcpsnoop`, sonst `~/.local/state/mcpsnoop`. Standardmäßig nimmt mcpsnoop
das Linux-Homeverzeichnis `/home/<user>` aus deinem `user@host` an und gibt eine Erinnerung
auf stderr aus, wann immer es auf diese Vermutung zurückfällt. Wenn das entfernte System den Pfad woanders auflöst, benenne das eine nicht standardmäßige Element.```bash
# a non-Linux or custom home, macOS is /Users/<user> and root is /root
mcpsnoop remote --remote-home /Users/remote-user remote-user@remote-host

# an explicit MCPSNOOP_HOME on the remote
mcpsnoop remote --remote-mcpsnoop-home /srv/mcpsnoop remote-user@remote-host

# an explicit XDG_STATE_HOME on the remote
mcpsnoop remote --remote-xdg-state-home /var/lib/state remote-user@remote-host

Um stattdessen eine lokale Kopie zu behalten, kopieren Sie die Logs per scp in Ihr Sessions-Verzeichnis und führen
Sie die TUI wie gewohnt aus.```bash
# copy the remote logs into your local sessions directory
mkdir -p ~/.local/state/mcpsnoop/sessions
scp remote-user@remote-host:'~/.local/state/mcpsnoop/sessions/*.jsonl' \
  ~/.local/state/mcpsnoop/sessions/

# open the TUI, it backfills the copied sessions
mcpsnoop

## Mitwirken

Issues und Pull Requests sind willkommen. Einzelheiten findest du in [CONTRIBUTING.md](https://github.com/kerlenton/mcpsnoop/blob/main/CONTRIBUTING.md).

## Lizenz

[MIT](https://github.com/kerlenton/mcpsnoop/blob/main/LICENSE)