Épinglez la version que vous souhaitez. La plus récente se trouve sur la
[page des versions](https://github.com/kerlenton/mcpsnoop/releases). Chaque entrée,
la signification des codes de sortie, et comment le brancher sans l'action sont détaillés
dans [L'action GitHub](#the-github-action) plus bas.

## Démarrage rapide

Voyez-le immédiatement, sans rien à configurer.```bash
mcpsnoop demo

Tout ce qui suit `--` est la commande qui lance normalement votre serveur. Remplacez-la par
ce que vous utilisez déjà, comme `python server.py`, `npx -y @scope/server`, ou un
binaire compilé.

Sur Claude Desktop, vous n'avez pas à effectuer cette modification à la main.```bash
mcpsnoop wrap my-server     # route my-server through mcpsnoop
mcpsnoop unwrap my-server   # put it back

Aucun drapeau, aucun chemin de socket, aucun ordre de démarrage à retenir. Le shim et l’interface se trouvent
mutuellement, et l’interface reconstitue les sessions passées depuis le disque.

Pour un serveur HTTP streamable, exécutez mcpsnoop en tant que proxy inverse.```bash
mcpsnoop http --target http://localhost:3000/mcp --listen :7000

Répétez `redact-key`, `redact-value` et `redact-path` sur leurs propres lignes pour en ajouter plus d’un de chaque.

Ce sont toutes les clés qu’il prend en charge.

Le fichier n’est recherché que dans le répertoire de travail actuel, pas dans les répertoires parents.

Les indicateurs explicites de la ligne de commande remplacent les valeurs du fichier de configuration.

## Commandes

| Commande | Ce qu’elle fait |
|---|---|
| `mcpsnoop -- <server>` | enveloppe un serveur stdio comme un shim transparent |
| `mcpsnoop` | ouvre la TUI en direct |
| `mcpsnoop http --target <url>` | sert de proxy à un serveur HTTP streamable |
| `mcpsnoop export` | rend une session en json, html, text, har ou otlp |
| `mcpsnoop check` | fait échouer la CI sur les erreurs, les trames invalides, les avertissements, les incohérences de routage, les appels bloqués, les résultats tardifs ou un budget de latence |
| `mcpsnoop baseline` | inspecte, accepte ou réinitialise les définitions d’outils approuvées |
| `mcpsnoop diff` | compare les outils et les appels entre deux sessions capturées |
| `mcpsnoop open` | ouvre une session enregistrée dans la TUI |
| `mcpsnoop inventory` | liste chaque serveur qui a transité par mcpsnoop sur cette machine |
| `mcpsnoop stats` | regroupe chaque capture stockée en une ligne par serveur et outil |
| `mcpsnoop prune` | supprime les journaux de sessions enregistrés plus anciens qu’un seuil |
| `mcpsnoop wrap <server>` | route l’un des serveurs de Claude Desktop via mcpsnoop |
| `mcpsnoop unwrap <server>` | remet l’entrée de ce serveur dans son état d’origine |
| `mcpsnoop remote <user@host>` | affiche la commande de tunnel SSH |
| `mcpsnoop demo` | joue une session scénarisée |

Exécutez `mcpsnoop help` pour la liste complète, ou `mcpsnoop help <command>` pour les indicateurs d’une commande.

## Comparaison

| | MCP Inspector | mcpsnoop |
|---|:---:|:---:|
| Voit votre trafic réel client et serveur | non | oui |
| Signale les appels bloqués et les erreurs de flux | non | oui |
| Signale les sorties parasites qui corrompent le flux | non | oui |
| Signale les trames JSON-RPC malformées | non | oui |
| Détecte la dérive des définitions d’outils après approbation | non | oui |
| Interface terminal interactive | non | oui |
| Zéro configuration, sans indicateurs ni ordre | non | oui |
| Inspecteur de capacités | partiel | oui |
| Rejoue un appel capturé | non | oui, via stdio et via HTTP |
| Export de session (json / html / text / otlp) | non | oui |
| Binaire unique, sans dépendances d’exécution | non | oui |

## Installation

### npm

Aucune chaîne d’outils Go requise. La plupart des serveurs MCP sont écrits en Node ou Python, c’est donc le chemin le plus court.```bash
npx mcpsnoop -- node build/index.js

### Homebrew```bash
brew install mcpsnoop

`--older-than` est requis (il n'y a pas de valeur par défaut qui supprimerait quoi que ce soit) et
accepte un nombre de jours comme `30d` ou une durée Go comme `72h`. Les références d'outils sont
laissées intactes, car une référence est associée à une étiquette de serveur plutôt qu'à une session.

Comme il se trouve dans le flux réel, et non en marge comme l'Inspector, il
voit exactement ce que votre client et votre serveur réels se disent, quel que soit le langage
dans lequel le serveur est écrit.

## Raccourcis clavier

| Touche | Action | | Touche | Action |
|---|---|---|---|---|
| `enter` | inspecter / explorer | | `/` | filtrer |
| `esc` | retour | | `:` | commande |
| `j` / `k` | déplacer | | `r` / `R` | rejouer / modifier et rejouer |
| `g` / `G` | haut / bas | | `c` | capacités |
| `ctrl-f` / `ctrl-b` | page | | `s` | résumé de l'outil |
| `p` | pause | | `y` | copier |
| `shift`+`<touche>` | trier par colonne | | `e` | exporter |
| `ctrl-d` | supprimer la session | | `f` | suivre |
| `?` | aide | | | |

Appuyez sur `?` dans l'application pour la liste complète.

## Filtrer le flux

Appuyez sur `/` dans une session et combinez des jetons séparés par des espaces, reliés par ET. Le texte brut
correspond à la méthode, à l'outil, à l'identifiant et à la charge utile.

| Jeton | Filtre par | Exemple |
|---|---|---|
| `tool:` | nom de l'outil | `tool:search` |
| `method:` | méthode JSON-RPC | `method:tools/call` |
| `id:` | identifiant de requête, et toute nouvelle tentative qui le poursuit | `id:7` |
| `task:` | identifiant de tâche | `task:01J...` |
| `dir:` | direction (`c2s`, `s2c`) | `dir:s2c` |
| `kind:` | type de trame (`req`, `resp`, `notify`, `stderr`, `invalid`) | `kind:invalid` |
| `status:` | résultat de l'appel (`ok`, `error`, `cancel`, `late`, `cancelled`, `pending`, `bad`, `warn`, `mismatch`, ou un statut HTTP comme `401`) | `status:error` |

Empilez les jetons pour être précis.```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 | Ce que vous obtenez |
|---|---|
| `json` | appels corrélés, comptages par outil et latences p50/p95/p99, appels les plus lents, capacités et trames brutes |
| `html` | un fichier navigateur autonome avec recherche et JSON repliable |
| `text` | un vidage en texte brut lisible |
| `har` | une entrée par appel corrélé, ouvrable dans les devtools du navigateur et tout autre outil lisant le HAR |
| `otlp` | JSON OTLP avec une span par appel corrélé, avec le contexte de trace W3C rejoignant les traces de l'appelant lorsqu'il est présent, et une trace par session sinon |

MCP n'est pas HTTP, donc l'URL, le code de statut et les timings d'une entrée HAR sont un
mappage délibéré de chaque appel plutôt qu'une transcription filaire.

Pour OTLP, le `_meta.traceparent` d'une requête fournit la trace et les IDs de span
parent de cet appel, et `_meta.tracestate` voyage avec la span. Lorsque le traceparent est
absent ou invalide, mcpsnoop conserve la trace dérivée de la session et ne transporte aucun état.
mcpsnoop observe plutôt qu'il ne participe, donc il n'ajoute aucune entrée de fournisseur qui lui soit propre
et transmet l'état de l'appelant sans modification.```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

Ces drapeaux réécrivent le fichier exporté ou la vue TUI en mémoire, jamais le
JSONL source. `export` refuse une sortie qui porte le même nom que son fichier
d'entrée, et écrit via un fichier temporaire renommé en place, de sorte qu'une
exécution qui échoue laisse le fichier précédent intact.

Les `inputSchema` et `outputSchema` d'un outil, telles qu'annoncées dans un
résultat `tools/list`, ne sont pas touchées par `--redact-key` et
`--redact-secrets`, pour trois raisons.

- Un nom dans un schéma est une déclaration de type plutôt qu'une valeur.
- Le nom lui-même reste dans le journal de toute façon.
- Nettoyer le sous-schéma sous une propriété appelée `token` emporterait avec
  lui les propres vérifications de l'outil.

L'exemption ne vaut qu'à cette position, donc un argument qui s'appelle par
hasard `inputSchema` est nettoyé comme n'importe quel autre, et elle s'arrête à
`default`, `const`, `examples` et `enum`, qui contiennent des données plutôt
que de la structure. Utilisez `--redact-path` pour nommer quelque chose à
l'intérieur d'un schéma, ou `--redact-value`, qui fait correspondre le texte où
qu'il se trouve, sauf dans les deux mots-clés que mcpsnoop analyse, `type` et
`x-mcp-header`.

Ce que chaque drapeau atteint diffère, alors vérifiez le résultat plutôt que de
supposer. Les quatre nettoient les charges utiles JSON-RPC, et `--redact-key`,
`--redact-path` et `--redact-secrets` n'atteignent que celles-ci. Seul
`--redact-value` nettoie aussi stderr, les autres textes non-JSON et
l'intérieur d'une chaîne. Un en-tête `Mcp-Param-*` est nettoyé en même temps
que la valeur du corps qu'il reflète. Les autres métadonnées d'enveloppe, les
étiquettes de serveur, `Mcp-Name`, `Mcp-Method` et le statut HTTP, sont
laissées telles que capturées. La rédaction est au mieux, alors utilisez un
chemin de sortie séparé et lisez le résultat avant de le partager.

### Diffuser les appels terminés vers un collecteur OTLP

Envoyez des spans pendant que le proxy tourne en le pointant vers un point de
terminaison de traces OTLP/HTTP JSON. Répétez `--otlp-header` pour
l'authentification du collecteur ou les en-têtes de locataire.```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

Le rapport montre les outils qui ont été ajoutés ou supprimés, les modifications de description et de `inputSchema`,
les appels d'outils correspondants dont le statut a changé, ainsi que les écarts de durée notables. Les appels
sont mis en correspondance par nom d'outil et arguments, de sorte que les appels réordonnés sont toujours comparés correctement.
Par défaut, les changements de durée doivent différer d'au moins 100 ms et d'un facteur 2. Utilisez
`--duration-threshold` et `--duration-ratio` pour ajuster ces seuils.

Passez `--exit-code` pour déclencher l'IC en cas de régressions. Il se termine avec un code non nul lorsque la session
« après » :

- supprime un outil
- modifie la description, le titre, le schéma d'entrée, le schéma de sortie ou les annotations d'un outil
- contient un appel dont le statut s'est dégradé
- ralentit

Un changement d'icône ne déclenche pas cela, car il modifie l'apparence d'un outil sans changer ce qu'il
fait. Les améliorations, c'est-à-dire les outils ajoutés, les appels corrigés et les accélérations, se terminent toujours
avec un code zéro.

## Vérification des sessions dans l'IC

Filtrez une session d'agent enregistrée sur les erreurs, la corruption du flux, les avertissements de protocole,
les incohérences d'en-tête de routage, les appels n'ayant jamais reçu de réponse, les trames supprimées qui
laissent la capture incomplète, la dérive des définitions d'outils ou l'utilisation de fonctionnalités de protocole
obsolètes.```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

### Signalez-le là où la CI regarde déjà

`--format junit` écrit un `<testcase>` par signal et par session, et ses échecs
suivent la même sélection `--fail-on` que la sortie texte.```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

Épingler une release, celle que vous voulez. La plus récente se trouve sur la
[page des releases](https://github.com/kerlenton/mcpsnoop/releases). Il n’y a
volontairement pas de `v1` flottant. La release épinglée est aussi le binaire
que l’action installe, donc les deux ne peuvent jamais diverger et il n’y a pas
de version par défaut qui risque de devenir obsolète.

| Entrée | |
|---|---|
| `session` | la capture `.jsonl` à vérifier, relative à la racine du dépôt. Requis |
| `fail-on` | comme `--fail-on`, avec pour défaut ce que le CLI utilise par défaut |
| `args` | tous les autres drapeaux de `check`, entre guillemets comme sur une ligne de commande. `--format` est refusé, car l’action lit le rapport |
| `upload-sarif` | envoyer le rapport au code scanning. `true` |
| `category` | l’espace de noms du code scanning. `mcpsnoop`. Variez-le par branche d’une matrice, sinon les branches s’écrasent mutuellement |
| `fail-on-findings` | faire échouer le job sur un constat. `true`. Mettez `false` pour déposer les alertes et laisser la vérification requise du code scanning décider |
| `version` | quelle version de mcpsnoop installer. Par défaut, la release que vous avez épinglée |
| `install` | `false` lorsque mcpsnoop est déjà dans le PATH, ce qui est la voie à suivre sur une plateforme pour laquelle aucune release n’est construite |

Les sorties sont `outcome`, `sarif` et `exit-code`. `outcome` vaut `passed`,
`findings` ou `error`, et la troisième mérite d’être traitée séparément. Elle
signifie que rien n’a été vérifié, ce qui n’est pas la même chose que rien n’a
été trouvé. **Une exécution qui n’a pas pu vérifier fait échouer le job, quoi
que dise `fail-on-findings`**, car un pipeline qui passe au vert sans avoir
rien vérifié est pire qu’un qui échoue.

Le job a besoin de `security-events: write`, sinon l’envoi répond 403. Mettez
`upload-sarif: false` dans un dépôt sans code scanning.

### Ou branchez-le vous-même

L’action est quatre étapes et aucune magie. Le faire à la main demande le même
soin qu’il faut. L’envoi doit s’exécuter sur les exécutions qui ont un rapport,
c’est-à-dire celles qui sont sorties avec 0 ou 1 et non celles sorties avec 2,
et l’étape qui fait échouer le job doit venir après, sinon les constats
n’atteignent jamais l’onglet pour lequel ils existent.```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

Dans le CI éphémère, le répertoire d'état démarre vide, donc une exécution n'a rien à comparer et enregistre la référence au lieu de la vérifier. **Une exécution qui devait échouer en cas de dérive puis n'a rien vérifié ne passe pas**, et indique quel répertoire conserver. C'est le seul cas où l'enregistrement d'une référence constitue un échec. Sans `drift` dans `--fail-on`, l'enregistrer est une opération courante et ne modifie aucun code de sortie.

La référence doit donc survivre entre les exécutions pour qu'un contrôle de dérive ait un sens. Pointez `--baseline` vers un répertoire versionné ou mis en cache, ou définissez `MCPSNOOP_HOME` sur un chemin persisté.```
recorded first-seen tool baseline (trusted, not verified)
check failed: drift

`drift` est activé sur option pour `check`. La porte par défaut `error,invalid,warn` reste inchangée.

### Détecter une fonctionnalité qu'aucun des deux côtés n'a négociée

SEP-2133 a déplacé les fonctionnalités optionnelles hors du protocole de base et dans des extensions,
annoncées dans la carte `extensions` des capacités de chaque côté. Tasks en fait partie,
donc le 2026-07-28, un `tasks/get`, un `notifications/tasks` ou un `tools/call`
répondu avec un identifiant de tâche n'a de sens que lorsque l'autre côté a déclaré
qu'il parle Tasks.

Lorsque ce n'est pas le cas, la spécification est explicite : la partie prenante DOIT soit
revenir au comportement de base, soit rejeter la requête. Le faire quand même est la raison pour laquelle une fonctionnalité
semble être câblée puis ne fait silencieusement rien, et ce qu'un lecteur obtient
à la place, c'est un `-32601` ou un `-32021` plusieurs trames plus tard, ou une tâche qui ne
progresse jamais. mcpsnoop émet un avertissement sur la trame qui a atteint l'extension et nomme
quel côté ne l'a jamais annoncée.```
tool "slow" answered with a task handle uses the io.modelcontextprotocol/tasks
extension, which the client never advertised

Comme `drift`, `deprecated` est opt-in. Une exécution par défaut signale le nombre et reste
verte, donc une session utilisant une fonctionnalité dépréciée encore légale ne fait jamais passer le CI au rouge à elle seule.

### Indicateurs de schéma que les clients gèrent mal

Un serveur peut être parfaitement valide et rester difficile à utiliser pour un agent. Les clients
diffèrent dans la mesure où ils prennent réellement en charge JSON Schema, et un outil que le modèle
continue d’appeler à tort est souvent un outil dont le schéma demandait plus que ce que le client
fournit.

Le résumé des outils, ouvert avec `s`, possède une colonne SCHEMA nommant l’élément le plus notable
du schéma de chaque outil annoncé, avec un `+` final lorsqu’il existe plus d’un type.

| Affiché | Signification |
|---|---|
| `no root` | le `inputSchema` est absent, n’est pas un objet JSON, ou possède un type racine autre que `"object"` |
| `dialect` | un `$schema` nommant un dialecte autre que le 2020-12 par défaut de la révision |
| `ext ref` | un `$ref` pointant hors du document, ce qui est aussi le cas que la spécification déconseille aux implémenteurs de suivre aveuglément |
| `oneOf`, `anyOf`, `allOf`, `not` | un mot-clé de composition, géré de manière incohérente selon les clients |
| `ref` | un `$ref` pointant à l’intérieur du même document |
| `untyped` | une propriété qui ne déclare aucun type ni aucun autre moyen d’indiquer ce qu’elle accepte |

Tous sauf le premier sont des observations plutôt que des verdicts. Un schéma utilisant `oneOf`
n’est pas faux, seulement susceptible d’être lu différemment par différents clients, et un
schéma peut déclarer le dialecte qu’il souhaite. `no root` est l’exception : la
définition `Tool` exige `inputSchema` et fixe son type racine à `"object"`, donc
un client validant un listing rejette cet outil d’emblée et il ne devient jamais
appelable, sans aucune indication sur le fil pour expliquer pourquoi. `no root` mène la colonne pour
cette raison, et un schéma que la propre rédaction de mcpsnoop a masqué n’est jamais signalé,
puisqu’un schéma illisible n’est pas un schéma erroné.

Cette répartition décide de ce que `check` en fait. `no root` est un avertissement sur la trame
`tools/list`, donc il échoue à la porte par défaut `error,invalid,warn` sans
aucun indicateur, ce qui est le but : un serveur qui livre un outil inutilisable répond
normalement à chaque poignée de main et ne reçoit simplement jamais de `tools/call`. Les
observations sont comptées comme `schema_findings` et signalées sous `schema
findings:`, et ne font échouer l’exécution que lorsque vous ajoutez `schema` à `--fail-on`. Les deux
atteignent `--format junit` et `--format sarif`, et `export` transporte la liste
par outil sous `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

Sans `--replay-target`, une session HTTP le signale plutôt que de proposer une clé qui ne peut pas fonctionner. Avec cette option, `r` demande toujours confirmation avant le premier envoi d'une session, de la même manière qu'une commande enregistrée est confirmée avant d'être exécutée.

Une information d'identification atteint le serveur via `--replay-header` et nulle part ailleurs. mcpsnoop n'enregistre aucun en-tête `Authorization` et n'en rejoue aucun, donc il n'y a rien de capturé qu'une relecture puisse divulguer.

Le POST rejoué transporte ce que le transport rend obligatoire, ce qu'un POST du corps capturé brut ne fait pas : `MCP-Protocol-Version`, un `Accept` listant à la fois `application/json` et `text/event-stream`, `Mcp-Method`, `Mcp-Name` là où la spécification l'exige, et chaque `Mcp-Param-*` capturé. Ceux-ci sont renvoyés tels quels depuis la capture, sentinelle base64 comprise, donc ils ne peuvent pas être en désaccord avec le corps comme une re-dérivation le pourrait. Le seul en-tête qui n'est pas copié est la version du protocole, car le corps rejoué déclare la révision que mcpsnoop parle et l'en-tête doit correspondre au corps.

`Mcp-Name` est dérivé du corps envoyé plutôt que copié, car la spécification le tire de `params.name` ou `params.uri` et exige qu'un serveur rejette un en-tête en désaccord avec le corps, donc une modification qui renomme l'outil enverrait sinon l'ancien nom. Les en-têtes `Mcp-Param-*` reflètent les arguments capturés, donc une relecture modifiée n'en envoie aucun plutôt que d'affirmer quelque chose sur un corps que quelqu'un a réécrit. Une capture ne peut définir des en-têtes que dans cette seule famille. Un journal est un fichier que les gens se transmettent, et lui permettre de nommer n'importe quel en-tête lui permettrait d'écraser les en-têtes obligatoires ou d'ajouter une information d'identification que personne n'a fournie.

Un `Mcp-Param-*` qu'une règle de rédaction a nettoyé arrête la relecture avec une raison. Envoyer le substitut mettrait les propres octets de mcpsnoop sur un serveur en direct comme si un utilisateur les avait saisis.

Une redirection est refusée plutôt que suivie. L'adresse est celle que vous avez nommée et confirmée, et suivre un 307 confierait ce choix à l'extrémité distante, renvoyant le corps et, sur un saut qui ne change que le port, l'information d'identification aussi. mcpsnoop signale où le serveur voulait l'envoyer et vous laisse décider si vous préférez nommer celle-ci à la place.

Une réponse arrivant comme un objet JSON unique et une arrivant comme un flux d'événements sont toutes deux lues, et un échec est nommé plutôt que numéroté :

- un 401 signale le schéma que le serveur a exigé
- un `-32020` signale ce à quoi il s'est opposé
- un 400 ou 404 non-JSON-RPC indique que l'adresse n'est pas un point de terminaison HTTP Streamable de cette révision

### Distinguer la latence du serveur de celle de l'utilisateur

Sous les requêtes multi-allers-retours, un appel d'outil correspond à plusieurs requêtes, et les secondes qu'une personne a passées à répondre à une sollicitation se situent à l'intérieur de l'intervalle. C'est délibéré, car cet intervalle est généralement celui que vous souhaitez le plus voir, mais cela signifie qu'un seul nombre ne peut pas répondre aux deux questions.

Sur une chaîne `book_flight` où le serveur a travaillé 1,2 seconde pendant que l'utilisateur en prenait 37, `check --max-duration 5s` accuse l'outil pour 38,2 secondes. Il le fait toujours, car changer ce que ce drapeau signifie assouplirait chaque pipeline qui le définit déjà. Deux frères nomment ce qu'ils mesurent à la place.```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

# 🚀 Installation

## 📦 Installation via pip

```bash
pip install pyrit

git clone https://github.com/Azure/PyRIT.git
cd PyRIT
pip install -e .

docker build -t pyrit .
docker run -it pyrit

pip install pyrit[all]

python -c "import pyrit; print(pyrit.__version__)"

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)
```
Les deux sont désactivés par défaut, donc une exécution `check` par défaut n'est pas affectée, et les deux sont
lus à partir des horodatages des frames et d'un lien que mcpsnoop a déjà déduit, donc aucun des deux ne
devine l'intention.

Appuyez sur `i` dans la TUI pour la ventilation, ou lisez `interactions` dans les exports json,
texte et html. Chaque entrée est une opération logique avec son nombre d'allers-retours,
son total, la part pendant laquelle le serveur l'a détenue et la part pendant laquelle elle attendait
le client, plus une ligne par saut nommant ce que chaque réponse demandait. Le
résumé par outil gagne une colonne `TRIPS` afin qu'un outil bavard soit visible sans
ouvrir quoi que ce soit.

`export --format har` place la part du serveur dans `wait` et le reste dans
`blocked`, ce qui est l'usage prévu pour ce champ, afin qu'un visualiseur cesse d'afficher une attente serveur de 38 secondes
qui n'a jamais eu lieu.

Les compteurs et les deux parts sont accumulés à mesure que les frames arrivent plutôt que
dérivés à la demande, car le stockage en direct libère les anciennes frames pour rester dans son
budget et une réponse dérivée serait silencieusement une fenêtre au lieu d'une chaîne.
La ventilation par saut est lue à partir des frames encore conservées, et le précise lorsqu'elle ne couvre
qu'une partie de l'une d'elles. `ServerTime + ClientTurnaround` est égal au total par
construction plutôt que par un calcul auquel il faudrait faire confiance.

`--max-round-trips` juge une chaîne encore en cours, car chaque requête
déjà émise est comptabilisable et un serveur qui redemande sans cesse produit
exactement l'opération que personne ne termine jamais. `--max-server-duration` attend une
fin, ce qui est la règle que `--max-duration` applique déjà, puisqu'une opération
encore ouverte n'a aucune latence à juger.

Une opération que mcpsnoop n'a pas pu relier reste sa propre entrée à un seul saut. `matchRetry`
refuse volontairement un lien ambigu, et cette vue ne comble pas cette lacune.

Une opération qui a nécessité une seule requête ne comporte aucune ventilation par saut, car un seul
saut reformule les totaux ci-dessus mot pour mot. Une chaîne rapporte un saut par
requête, et le précise lorsque le stockage ne conserve plus chaque frame ou lorsque le travail
s'est réglé en dehors de la paire requête et réponse dont un saut est constitué, ce qu'un
handle de tâche fait.

### Voir ce qu'un serveur a demandé à votre utilisateur

L'élicitation est le seul chemin dans MCP où une personne saisit des données dans un serveur, et
sous MRTR la question et la réponse ne sont plus deux moitiés d'un même échange.
La question est enfouie dans un `InputRequiredResult`, la réponse revient dans
`inputResponses` lors d'une nouvelle tentative sous un identifiant différent, et la seule chose qui les
relie est le lien que mcpsnoop déduit déjà.

Sans ce couplage, une demande de mot de passe refusée se lit comme une simple erreur d'outil.```
tools/call login_legacy [form] creds: decline after 3s
  password string
```
Appuyez sur `l` dans la TUI, ou lisez `elicitations` dans les exports json, texte et html.
Chaque ligne nomme l'opération que la question a interrompue, le mode, le message,
ce qui a été demandé, ce que l'utilisateur a fait et combien de temps il a pris. Une question à laquelle
aucune nouvelle tentative n'a jamais répondu apparaît comme en attente, ce que MRTR considère comme un résultat
ordinaire plutôt qu'une erreur, puisque la spécification indique aux serveurs de ne pas supposer qu'un client
fera une nouvelle tentative du tout.

Les lignes de formulaire listent les noms de propriétés `requestedSchema` et leurs types déclarés. Une
propriété dont le sous-schéma a été remplacé par une règle de rédaction affiche un type inconnu plutôt que
l'espace réservé, car un espace réservé n'est pas quelque chose que le serveur a déclaré. Les lignes d'URL portent
l'adresse entière, que la spécification demande à un client d'afficher avant le consentement, et nomment l'hôte
séparément, ce qu'elle dit de mettre en évidence contre l'usurpation de sous-domaine.

Le registre ne contient jamais une valeur soumise. Ce que l'utilisateur a saisi reste dans la
capture pour quiconque en a besoin, et le laisser hors d'une surface de synthèse conçue pour être exportée
et collée partout est ce qui le maintient entièrement hors de l'histoire de la rédaction.
Cela importe surtout en mode url, où la spécification place les identifiants
délibérément.

Une nouvelle tentative répond au tour d'où elle a été émise et à aucun autre. MRTR indique à un serveur
que lorsqu'un client omet une partie de ce qui a été demandé, il doit redemander dans un nouveau tour,
donc un tour antérieur contenant une clé sans réponse à côté d'une clé répondue est un trafic
ordinaire, et la moitié sans réponse reste en attente plutôt que d'emprunter la réponse du tour
suivant.

Une question enregistrée est bornée. Le message, l'url et la liste de champs sont conservés
pour la durée de la session, hors du budget de trame qui libère les corps,
donc un serveur ne peut pas en rendre une arbitrairement coûteuse. Les limites sont bien au-dessus de toute
question réelle et un message tronqué indique qu'il a été tronqué.

Rien ici n'avertit et rien ici ne modifie un code de sortie `check`. Un registre
enregistre ce qui s'est passé. Il ne le juge pas.

### Trouver l'outil qui échoue une fois sur quatre

`check` lit une session et `diff` en lit exactement deux, donc un outil qui échoue
occasionnellement reste invisible jusqu'à ce que quelqu'un ouvre les captures à la main. Sur
seize captures d'un serveur dont `run_query` répond `isError` environ un quart
du temps, `check` signale la plus récente, honnêtement, comme propre.```bash
mcpsnoop stats
mcpsnoop stats --since 7d --label prod
mcpsnoop stats --limit 20 --format json
```
```
# 🛡️ Kitploit — Outils de cybersécurité open-source

Bienvenue dans **Kitploit**, votre répertoire de référence pour les outils de cybersécurité open-source. Cette collection est organisée pour vous aider à découvrir, explorer et utiliser une large gamme d'outils de sécurité — des scanners de vulnérabilités aux frameworks d'exploitation, en passant par les outils de renseignement sur les menaces et les utilitaires de réponse aux incidents.

---

## 📚 Table des matières

- [À propos](#à-propos)
- [Catégories](#catégories)
- [Outils en vedette](#outils-en-vedette)
- [Comment contribuer](#comment-contribuer)
- [Licence](#licence)

---

## ℹ️ À propos

Kitploit est une plateforme communautaire qui regroupe et met en avant les meilleurs outils de cybersécurité open-source. Notre objectif est de fournir un point d'accès unique aux professionnels de la sécurité, aux chercheurs et aux passionnés pour découvrir de nouveaux outils, rester informés des dernières versions et partager leurs propres projets.

---

## 🗂️ Catégories

Les outils sont classés dans les catégories suivantes :

- **Reconnaissance** — Collecte d'informations et découverte de la surface d'attaque
- **Analyse de vulnérabilités** — Identification et évaluation des failles de sécurité
- **Exploitation** — Frameworks et outils pour tester les vulnérabilités
- **Post-exploitation** — Mouvement latéral, élévation de privilèges et persistance
- **Forensique** — Analyse de la mémoire, des disques et des artefacts réseau
- **Renseignement sur les menaces** — Suivi des menaces, des IOC et des campagnes
- **Sécurité réseau** — Analyse du trafic, pare-feu et outils de surveillance
- **Sécurité web** — Tests d'applications web et API
- **Sécurité mobile** — Tests d'applications Android et iOS
- **Sécurité cloud** — Évaluation de la sécurité des environnements cloud
- **Ingénierie sociale** — Phishing, simulation et sensibilisation
- **Cryptographie** — Chiffrement, hachage et outils d'analyse

---

## ⭐ Outils en vedette

Voici quelques outils populaires actuellement mis en avant sur Kitploit :

### 1. [Nmap](https://nmap.org)
**Catégorie :** Reconnaissance  
Nmap (Network Mapper) est un outil open-source de découverte de réseau et d'audit de sécurité. Il est utilisé pour découvrir les hôtes et les services sur un réseau informatique, créant ainsi une « carte » du réseau.

### 2. [Metasploit Framework](https://www.metasploit.com)
**Catégorie :** Exploitation  
Metasploit est un framework d'exploitation open-source qui fournit des informations sur les vulnérabilités de sécurité et aide au développement et à l'exécution de code d'exploitation contre une machine cible distante.

### 3. [Burp Suite Community Edition](https://portswigger.net/burp)
**Catégorie :** Sécurité web  
Burp Suite est une plateforme intégrée pour effectuer des tests de sécurité d'applications web. L'édition communautaire comprend un proxy, un scanner et divers outils pour les tests manuels.

### 4. [Wireshark](https://www.wireshark.org)
**Catégorie :** Sécurité réseau  
Wireshark est un analyseur de protocoles réseau. Il vous permet de capturer et d'inspecter de manière interactive le trafic réseau en cours d'exécution sur un réseau informatique.

### 5. [John the Ripper](https://www.openwall.com/john/)
**Catégorie :** Cryptographie  
John the Ripper est un outil de craquage de mots de passe rapide, conçu pour tester la robustesse des mots de passe et récupérer les mots de passe perdus.

---

## 🤝 Comment contribuer

Nous accueillons les contributions de la communauté ! Pour soumettre un outil ou une mise à jour :

1. **Forkez** ce dépôt.
2. **Créez une branche** pour votre fonctionnalité (`git checkout -b feature/nouvel-outil`).
3. **Commitez** vos modifications (`git commit -am 'Ajout d'un nouvel outil : [Nom]'`).
4. **Poussez** vers la branche (`git push origin feature/nouvel-outil`).
5. **Ouvrez une Pull Request** avec une description claire de vos modifications.

Assurez-vous que votre soumission respecte nos [directives de contribution](https://github.com/kerlenton/mcpsnoop/blob/main/CONTRIBUTING.md).

---

## 📄 Licence

Ce projet est sous licence MIT — consultez le fichier [LICENSE](https://github.com/kerlenton/mcpsnoop/blob/main/LICENSE) pour plus de détails.

---

## 🙏 Remerciements

Merci à tous les contributeurs et à la communauté open-source de la cybersécurité pour leur travail acharné et leur dévouement à rendre le monde numérique plus sûr.

---

*Dernière mise à jour : [Date]*

`ERR` et `PROTO` sont des colonnes distinctes car la spécification en fait
des choses distinctes. Un outil qui répond `isError` signale quelque chose sur
lequel un modèle peut agir et réessayer. Une erreur JSON-RPC signifie que la
requête ou le serveur est en tort.
`SESS` est le nombre de sessions ayant vu un échec parmi les sessions ayant
appelé l'outil, ce qui répond à la question « une exécution sur dix » qu'un
taux par appel ne peut pas résoudre.

Les lignes sont indexées conjointement sur le serveur et le libellé. Le serveur
est la commande et le répertoire de travail enregistrés pour stdio et le point
de terminaison pour HTTP, la même identité qu'utilise `inventory`. Chaque moitié
seule regroupe ce qu'elle ne devrait pas : le libellé seul fusionne deux
serveurs qui dérivent d'un même nom, ce qui arrive chaque fois que deux
extractions d'un projet exécutent le même point d'entrée, et l'identité seule
fusionne une commande délibérément exécutée en `prod` puis en `staging`. Ces
deux erreurs mélangent deux distributions propres en une seule qui ne décrit
ni l'une ni l'autre.

Lorsque deux lignes partagent un libellé, la cellule `SERVER` porte le
répertoire de travail ou le point de terminaison qui les distingue, et le JSON
porte `command`, `cwd` et `endpoint` sur chaque ligne. Un nom qui n'a jamais
été ambigu est laissé tel quel, donc le tableau ordinaire reste inchangé.

Chaque session d'un journal est repliée, pas seulement la première, donc un
fichier créé par concaténation de captures compte toutes les sessions.

Les percentiles sont regroupés sur les durées brutes. Une médiane de médianes
est une médiane de rien. Une opération à plusieurs allers-retours est un appel
avec une seule durée, quel que soit le nombre de requêtes nécessaires, et un
appel encore ouvert compte dans `CALLS` sans contribuer à la latence.

Une seule capture est résidente à la fois. Un journal est chargé, replié dans
les compteurs en cours, puis abandonné avant l'ouverture du suivant, donc un
répertoire de centaines de fichiers coûte la plus grande capture individuelle
plutôt que leur somme.

`--limit` est par défaut de cent journaux les plus récents et l'en-tête indique
combien sur combien ont été lus, donc une réponse bornée ne passe jamais pour
une réponse complète. `stats` rapporte et ne bloque pas : il n'écrit rien, ne
touche à aucune référence, n'ouvre aucun socket et sort avec le code 0 dès que
la traversée a réussi.

### Voir quels serveurs ont réellement tourné ici

Le constat que les gens répètent sans cesse à propos de Shadow MCP est que les
organisations découvrent plusieurs fois plus de serveurs MCP en cours
d'exécution que ce que quiconque a approuvé, car un serveur est souvent
simplement une dépendance que quelqu'un a ajoutée à un plugin d'IDE. La même
chose se produit à petite échelle sur un seul ordinateur portable, et mcpsnoop
enregistre la réponse depuis le début sans jamais l'afficher.```bash
mcpsnoop inventory
mcpsnoop inventory --tools          # also count what each server last advertised
mcpsnoop inventory --format json    # for something else to read

### Voyez ce que le serveur vous coûte en contexte

Les définitions d'outils entrent dans le contexte du modèle à chaque conversation, et les
résultats d'outils à chaque appel. Le résumé d'outil (`s`) mesure les deux à partir de la session
que vous avez réellement capturée.

La ligne `definitions` est le coût fixe : ce que pèse le `tools/list` de ce serveur
avant qu'un seul appel ne soit effectué. La colonne `DEF` décompose cela par
outil et `RESULT` est ce que les réponses de chaque outil ont coûté jusqu'à présent. Le tableau reste
trié par erreurs et latence, alors parcourez `DEF` pour trouver les définitions coûteuses.
L'export les liste des plus lourdes aux plus légères. Une ligne sous le tableau nomme le
résultat unique le plus lourd, qu'un total masque.

Les chiffres de définition sont le JSON avec les espaces insignifiants supprimés, donc un
serveur qui imprime joliment son `tools/list` n'est pas compté comme plus coûteux qu'un
autre qui ne le fait pas, et le même serveur mesure la même chose entre les captures.
`RESULT` correspond aux octets tels qu'ils sont arrivés : un résultat est une charge utile ponctuelle plutôt
qu'un contrat qui mérite d'être normalisé.```bash
mcpsnoop export -T json | jq '.summary.definitions'

Le socket se trouve sous le répertoire d'état du système distant, résolu comme `MCPSNOOP_HOME`,
sinon `XDG_STATE_HOME/mcpsnoop`, sinon `~/.local/state/mcpsnoop`. Par défaut, mcpsnoop
suppose le répertoire personnel Linux `/home/<user>` à partir de votre `user@host` et affiche un rappel
sur stderr chaque fois qu'il retombe sur cette supposition. Si le système distant résout ailleurs,
nommez la pièce non par défaut.```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

Pour conserver une copie locale à la place, copiez les journaux via scp dans votre répertoire de sessions, puis exécutez
le TUI comme d'habitude.```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

## Contributing

Les issues et les pull requests sont les bienvenues. Consultez [CONTRIBUTING.md](https://github.com/kerlenton/mcpsnoop/blob/main/CONTRIBUTING.md) pour
plus de détails.

## License

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