## Install

### Homebrew (macOS / Linux)```sh
brew install raskrebs/sonar/sonar

### Script d'installation```sh
curl -sfL https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.sh | bash

Custom install location:```sh
curl -sfL https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.sh | SONAR_INSTALL_DIR=/usr/local/bin bash

I don't see any input content to translate. Please provide the Markdown chunk you'd like me to translate from English to French.```powershell
$env:SONAR_VERSION="vX.Y.Z"; irm https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.ps1 | iex

Complétions du shell (complétion par tabulation des numéros de port) :```sh
sonar completion zsh > "${fpath[1]}/_sonar"   # zsh
sonar completion bash > /etc/bash_completion.d/sonar  # bash
sonar completion fish | source                 # fish

Le nom du groupe provient du dépôt, donc rien d'autre n'a besoin d'être configuré.
Dans un autre terminal :```sh
sonar list --tree

Et lorsque vous avez terminé, arrêtez tout le projet — serveurs, watchers et workers :```sh
sonar kill -g my-app

Veuillez fournir le contenu Markdown à traduire.```sh
sonar list --stats             # CPU, memory, threads, uptime, state
sonar list --health            # HTTP health checks
sonar list --filter docker     # only Docker ports
sonar list --sort name         # port | pid | name | type
sonar list -a                  # include desktop apps
sonar list -c port,process,group,cpu,mem
sonar list --host user@server  # scan a remote machine over SSH

Rien n'a besoin d'être transmis :

- **Groupe** — `--group`, sinon le `name` dans le `.sonar.yaml` le plus proche, sinon le
  nom du répertoire racine du dépôt git (un worktree devient `repo@worktree`), sinon le nom
  du répertoire courant.
- **Nom** — `--name`, sinon le service `.sonar.yaml` dont le `cmd` correspond, sinon
  déduit de la commande (`npm run dev` → `dev`, `uv run api` → `api`,
  `python -m uvicorn` → `uvicorn`, `./dev.sh` → `dev.sh`).
- **Port** — `--port` est une indication, pas une contrainte : l'exécution s'affiche comme `starting`
  jusqu'à ce que le port écoute réellement, et le démon l'utilise pour faire correspondre le
  processus au port.

Le processus enfant hérite de stdin, stdout, stderr, du répertoire de travail et de l'environnement, plus
`SONAR_GROUP`, `SONAR_NAME` et `SONAR_RUN_ID`. Il obtient son propre groupe de processus,
donc `sonar kill` arrête toute l'arborescence — un serveur de développement avec ses watchers et ses
workers. Ctrl+C est transmis, et sonar se termine avec le code de sortie du processus enfant.

`--detach` renvoie immédiatement et écrit la sortie dans
`~/.config/sonar/logs/<group>/<name>.log`. `--list` affiche ce que sonar a démarré
(`--json` pour la forme lisible par machine) :```sh
sonar start --list
sonar start --detach --name demo --port 8123 -- sleep 5
sonar start --list --json
# check

- `name` — le nom du groupe. Pas de barres obliques, pas d'espaces.
- `cmd`, `cwd`, `port` — comment `sonar up` démarre le service. `cwd` est relatif au
  fichier et ne peut pas sortir de son répertoire.
- `health` — un chemin HTTP que le démon interroge pendant que le service est actif, afin
  qu'un service puisse être *en cours d'exécution* mais pas encore *sain*. Il rapporte `ok`, `fail` ou
  `unknown`, avec la raison en cas d'échec.
- `description`, `icon`, `color` — métadonnées libres pour l'application de bureau ; sonar
  ne les déduit jamais.
- `depends_on` — ordre de démarrage. Nommer un service qui n'est pas dans le fichier, ou une
  boucle, est une erreur ; un fichier invalide est signalé une fois et n'interrompt jamais une analyse.

`.sonar.yml` est lu si c'est ainsi que vous l'écrivez ; `sonar init` écrit toujours
`.sonar.yaml`. Le démon surveille les projets qu'il connaît et prend en compte les
modifications du fichier sans redémarrage. Chaque modification que sonar effectue — depuis l'application
de bureau, depuis `sonar groups add`, `rename` et `remove`, depuis un agent — passe
par le démon, qui régénère le fichier à partir de son propre arbre syntaxique, de sorte que
les commentaires, l'ordre des clés et la mise en page survivent à une modification qui ajoute, renomme ou supprime un
service, tout comme ils survivent à un changement de métadonnées. La seule exception : les espaces supplémentaires
alignant un commentaire de fin (`cmd: x     # note`) se réduisent à un seul, car la
bibliothèque YAML conserve le commentaire mais pas sa colonne.

### `sonar up````sh
sonar up                       # the .sonar.yaml at or above this directory
sonar up my-app                # a group by name
sonar up --only api,frontend
sonar up --json

Un service qui ne démarre pas est signalé sur sa propre ligne et fait que la commande
se termine avec un code non nul, quel que soit le reste. Arrêtez-les tous à nouveau avec
`sonar kill -g my-app`. `sonar up` nécessite le démon et le démarre s’il n’est pas
déjà en cours d’exécution.

### `sonar groups` et `sonar init````sh
sonar init --dry-run
sonar init --service api:8000:/healthz --service web:5173
sonar groups
sonar groups --json

group=$(basename "$PWD")           # sonar init names the group after the directory
sonar groups add "$group" worker --port 9000 --cmd 'uv run worker' --depends-on api
sonar groups rename "$group" worker jobs
sonar groups remove "$group" jobs
# check

`--dry-run` accepte n'importe quel sélecteur et ne modifie rien : il affiche les actions que le
kill effectuerait, en commençant par les enfants, et laisse tout en cours d'exécution. De bout en bout,
contre un listener qui vous appartient :```sh
sonar start --detach --name plan --port 8231 -- sonar map 3000 8231
sonar wait 8231
sonar kill 8231 --dry-run --json           # the plan; the mapping keeps running
sonar kill 8231 -y                         # and now for real
# check

Exécute un proxy TCP au premier plan jusqu'à ce que vous l'arrêtiez. `sonar kill` signale
un mappage qu'il a arrêté comme `map_stop`.

### `sonar rename`, `sonar assign`, `sonar history````sh
sonar rename 3000 storefront     # a name of your own, survives restarts
sonar rename 3000 --clear
sonar assign 3000 my-app         # pin a port to a group by hand
sonar assign 3000 --clear
sonar history                    # everything that came up, went down, restarted
sonar history 3000 --since 24h --limit 20

Names et pins sont stockés dans la base de données de sonar, indexés par l'élément le plus spécifique
connu sur le port : le run (`run:<group>/<name>`), le conteneur
(`docker:<project>/<service>`), le répertoire de travail, et le numéro de port en
dernier. Un serveur de développement renommé conserve son nom entre les redémarrages ; un nom épinglé au
port 3000 seul s'applique à tout ce qui y répond. Ces trois commandes nécessitent
le démon et le démarrent s'il n'est pas en cours d'exécution.

### Lecture d'un port```sh
sonar info 3000                            # command, user, bind, stats, health
sonar logs 3000                            # tail; docker logs for containers
sonar wait 5432 3000 --timeout 60s         # block until ready
sonar wait 5432 --http=/health             # wait for HTTP 200-399, not just TCP
sonar next 3000                            # first free port from 3000
sonar next 3000-3100 -n 3                  # three consecutive free ports
sonar graph                                # who is connected to whom
sonar graph --dot                          # Graphviz
sonar open 3000                            # open in the browser
sonar attach 3000                          # shell into the container, or TCP
sonar watch                                # live view
sonar watch --stats --notify

## 📦 Installation

### Option 1: Install via pip

```bash
pip install kitploit

git clone https://github.com/kitploit/kitploit.git
cd kitploit
pip install -r requirements.txt
python setup.py install

docker pull kitploit/kitploit
docker run -it kitploit/kitploit

kitploit --help

kitploit search nmap

kitploit info metasploit

kitploit search "network scanner"
kitploit search "password cracking"
kitploit search "web vulnerability"

kitploit info burpsuite
kitploit info sqlmap
kitploit info wireshark

kitploit list
kitploit list --category "exploitation"
kitploit list --category "reconnaissance"

kitploit update

# Kitploit configuration file
settings:
  language: en
  theme: dark
  cache_enabled: true
  cache_timeout: 3600

api:
  base_url: "https://api.kitploit.com"
  api_key: "your-api-key-here"
  timeout: 30

kitploit category create "my-tools"
kitploit category add "my-tools" "custom-tool-name"

kitploit search "exploit" --export json
kitploit search "exploit" --export csv
kitploit info "metasploit" --export markdown

kitploit batch update --all
kitploit batch check --category "exploitation"

kitploit db init
kitploit db rebuild
kitploit db verify

kitploit db backup --output "backup.json"
kitploit db restore --input "backup.json"

# Example GitHub Actions workflow
name: Security Tool Update
on:
  schedule:
    - cron: '0 0 * * *'
jobs:
  update-tools:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install Kitploit
        run: pip install kitploit
      - name: Update tool database
        run: kitploit update
      - name: Check for outdated tools
        run: kitploit check --outdated

sonar next 3000
sonar next 3000-3100 -n 3 --json
sonar graph --json
sonar info --help
# check
```
`sonar wait` se termine avec le code `0` (prêt), `1` (délai dépassé) ou `2` (interrompu), ce qui en fait
l'outil idéal à placer entre le démarrage de quelque chose et son test :```sh
docker compose up -d
sonar wait 5432 3000 --timeout 60s && npm run migrate && npm run test
```
**Daemon ou analyse directe.** Chaque commande de lecture interroge le daemon si l’un d’eux est
en cours d’exécution, car il possède déjà la réponse et n’a pas à forker `lsof`.
Si aucun n’est en cours d’exécution, ils analysent directement et impriment une note sur stderr le signalant.
`sonar kill` suit la même règle : un daemon accessible effectue le kill, donc il
réanalyse immédiatement et sa réponse suivante — ainsi que l’historique des ports — sait déjà
que le port est fermé. Ni les lectures ni les kills ne démarrent un daemon à votre insu.
`--no-daemon` force l’analyse directe silencieusement et fonctionne sur toute commande :```sh
sonar list --no-daemon --json
# check
```
### `sonar host````sh
sonar host          # cpu, load, memory and disk of the machine sonar watches
sonar host --json
```
```
## 📦 Installation

### Option 1: Install via pip

```bash
pip install kitploit
```

### Option 2: Install from source

```bash
git clone https://github.com/kitploit/kitploit.git
cd kitploit
pip install -r requirements.txt
python setup.py install
```

### Option 3: Use Docker

```bash
docker pull kitploit/kitploit
docker run -it kitploit/kitploit
```

## 🚀 Quick Start

After installation, you can start using Kitploit immediately:

```bash
kitploit --help
```

To search for a specific tool:

```bash
kitploit search nmap
```

To get detailed information about a tool:

```bash
kitploit info metasploit
```

## 📚 Usage Examples

### Searching for tools

```bash
kitploit search "network scanner"
```

### Browsing categories

```bash
kitploit categories
kitploit category web
```

### Updating the local database

```bash
kitploit update
```

## 🛠️ Configuration

Kitploit can be configured via a configuration file located at `~/.kitploit/config.yaml`:

```yaml
# Example configuration
database:
  path: ~/.kitploit/tools.db
  auto_update: true

cache:
  enabled: true
  ttl: 3600

output:
  format: table
  color: auto
```

## 🤝 Contributing

We welcome contributions from the community! Here's how you can help:

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](https://github.com/raskrebs/sonar/blob/main/LICENSE) file for details.

## 🙏 Acknowledgements

- All the open-source security tools featured in our directory
- The amazing cybersecurity community
- Our contributors and maintainers

## 📞 Contact

- **Website**: [https://kitploit.com](https://kitploit.com)
- **Twitter**: [@kitploit](https://twitter.com/kitploit)
- **GitHub**: [Kitploit](https://github.com/kitploit)

---

**Happy Hacking!** 🎯
``````sh
sonar host
# check
```
Le démon mesure sa propre machine selon la cadence d'analyse et la publie sous forme de
ligne `localhost` dans la collection `hosts` de l'instantané : système d'exploitation et noyau, temps de fonctionnement, pourcentage de CPU, charge moyenne, mémoire et le disque contenant `/`. Le pourcentage de CPU correspond au travail effectué entre deux analyses, il est donc nul jusqu'à ce que le démon ait analysé deux fois ; une valeur qu'une plateforme ne peut pas produire — la charge moyenne sous Windows, qui n'en a pas — est nulle plutôt que zéro. Chaque hôte enregistré avec `sonar remote add` rejoint la même table avec sa propre charge. La commande nécessite un démon en cours d'exécution : c'est le démon qui conserve l'échantillon précédent par rapport auquel un pourcentage est mesuré.

### `sonar remote install````sh
sonar remote install [email protected]        # same version as this sonar
sonar remote install hetzner --version v0.6.0  # a Host from ~/.ssh/config
sonar remote install deploy@box --no-service   # the binary, no daemon
```
Pose un sonar sur un hôte auquel vous pouvez déjà vous connecter en SSH et y démarre son démon. L'archive de la version est téléchargée et vérifiée par somme de contrôle **sur l'hôte distant** — rien n'est copié depuis cette machine — et le binaire est placé dans `~/.local/bin/sonar`, donc rien ne nécessite les droits root. Le démon s'exécute en tant qu'unité utilisateur systemd lorsque l'hôte en possède une (`~/.config/systemd/user/sonar.service`), et en mode détaché dans le cas contraire ; `loginctl enable-linger` est affiché comme conseil lorsque la session utilisateur se terminerait à la déconnexion et emporterait le démon avec elle.

La version installée est celle du sonar à partir duquel vous l'avez exécuté, afin que les deux extrémités parlent le même protocole. Le relancer effectue une mise à niveau sur place et redémarre le démon, ce qui fait de l'installation et de la mise à jour une seule et même commande.

La cible est transmise à `ssh` telle quelle : un alias `Host` de `~/.ssh/config` fonctionne, tout comme les `ProxyJump`, `IdentityFile` et `Port` qu'il définit. `--identity` et `--ssh-arg` sont là pour les options qu'une configuration ne couvre pas.

### `sonar remote````sh
sonar remote add [email protected]            # name taken from the target
sonar remote add hetzner [email protected]    # or given
sonar remote list                              # status, latency, version, load
sonar remote remove hetzner

sonar list --host hetzner                      # that host's ports
sonar list --host "*"                          # every host, with a HOST column
sonar info 3000 --host hetzner
```
Un hôte enregistré exécute le même démon, et le démon de cette machine conserve
une connexion SSH vers lui — `ssh <target> sonar daemon stdio` — et multiplexe
ce qu'il rapporte dans l'état que chaque client lit déjà. Rien de nouveau n'écoute
où que ce soit : le socket du démon distant reste privé pour l'utilisateur SSH, et
les clients ne parlent jamais SSH eux-mêmes.

Chaque ligne porte désormais l'hôte dont elle provient. Les lignes locales indiquent `localhost` et
conservent les clés qu'elles ont toujours eues, donc rien de ce qui lit sonar aujourd'hui ne change ;
les lignes distantes indiquent le nom enregistré et sont indexées par `<host>/<port>:<bind>`, ce qui
permet au port 3000 de deux machines d'être deux lignes distinctes. Un abonné ne voit que
localhost sauf s'il demande plus (`state.subscribe {"hosts": ["*"]}`).

La cible va vers `ssh` sans modification, donc les alias `~/.ssh/config`, `ProxyJump` et
les identités s'appliquent tous ; `--ssh-arg`, `--identity` et `--port` couvrent ce qu'une config ne
fait pas. sonar ne stocke ni mot de passe ni clé. Un hôte qui disparaît conserve sa
ligne et son statut pendant que le démon réessaie, en espaçant les tentatives d'une seconde à
trente tant qu'il reste enregistré.

`--host` accepte aussi toujours un simple `user@host` dont sonar ne sait rien : il
retombe sur l'analyse sans agent `ssh` + `ss`/`lsof` et affiche une indication pour
`sonar remote install`.

#### Agir sur une autre machine

Chaque écriture accepte aussi `--host`, et fait là-bas exactement ce qu'elle fait ici :```sh
sonar kill 3000 --host hetzner                 # stop a port on that machine
sonar kill -g api --host hetzner               # a whole group of its services
sonar kill-all --filter docker --host hetzner  # its containers
sonar up api --host hetzner                    # start a group from its .sonar.yaml
sonar logs 3000 --host hetzner                 # tail its output here
sonar rename 3000 storefront --host hetzner    # its name, in its database
sonar assign 3000 storefront --host hetzner
```
Le démon local transmet l'appel via le pont de cet hôte et renvoie ce que
le démon distant a répondu, dans la même enveloppe qu'un appel local renvoie — chaque
ligne de résultat indique sur quel hôte elle s'est produite, et le `affected` d'un kill porte
les clés `<host>/<port>:<bind>` que le flux utilise pour ces lignes. Une commande en
flux continu diffuse : `sonar up --host` affiche chaque service au fur et à mesure que le côté distant le démarre, et
Ctrl-C arrête le travail distant plutôt que seulement ce terminal.

Comme la clé d'une ligne nomme déjà son hôte, un client peut la renvoyer directement
comme sélecteur — `{"key": "hetzner/3000:127.0.0.1"}` constitue l'intégralité d'un sélecteur,
hôte compris. Un appel agit sur une seule machine ; en nommer deux est une erreur plutôt
qu'un demi-kill sur chacune.

Deux choses restent locales. `sonar attach` place *ce* terminal devant un
processus, donc il refuse `--host` et indique de se connecter en ssh et de s'y attacher. Et une
session d'agent est un état que ce démon détient, donc `sonar kill --session` n'a pas de
forme distante. Tout le reste nécessite que le démon tourne ici — c'est là que vit la
connexion vers l'autre machine — et le précise au lieu de scanner silencieusement cette machine à la place.

`sonar up --host` nécessite que le groupe soit nommé : le `.sonar.yaml` dans votre
répertoire de travail est un chemin sur cette machine, et c'est le démon distant qui lit le
fichier et démarre les services.

### Le démon

Un processus en arrière-plan scanne les ports, résout les groupes, interroge la santé, tient la
base de données et diffuse les changements à quiconque est abonné — la CLI, l'application
de bureau et les éditeurs.```sh
sonar serve                  # in the foreground
sonar serve --detach         # in the background
sonar daemon status          # pid, uptime, subscribers, scans, intervals
sonar daemon path            # the socket it listens on
sonar daemon log -n 50 -f    # what it is doing
sonar daemon restart
sonar daemon stop
```
I'm ready to translate the Kitploit tool content from English to French. Please provide chunk 77 of 107.```sh
sonar daemon path
sonar daemon status --json
sonar daemon log -n 5
# check
```
| Quoi | Où |
|---|---|
| Socket | `$XDG_RUNTIME_DIR/sonar/daemon.sock`, sinon `~/.config/sonar/daemon.sock` ; `\\.\pipe\sonar` sur Windows |
| Base de données | `~/.config/sonar/sonar.db` (`SONAR_DB` prioritaire) |
| Journal du démon | `~/.config/sonar/daemon.log`, rotation à 5 Mio, trois conservés |
| Journaux d'exécution | `~/.config/sonar/logs/<groupe>/<service>.log` |
| Configuration | `~/.config/sonar/config.yaml` |

`SONAR_SOCKET` remplace le chemin du socket partout, à la fois pour le démon et
ses clients — utile pour une seconde instance isolée. Le socket est créé
en 0600 dans un répertoire 0700, donc seul vous pouvez y accéder. Un seul démon
s'exécute à la fois ; un socket laissé par un crash est nettoyé au prochain
démarrage.

Le démon s'arrête de lui-même après 30 minutes sans clients et sans
abonnés. Définissez `daemon.idle_timeout` dans le fichier de configuration pour
modifier cela, ou `0` pour le laisser tourner.

Les ports sont analysés toutes les 2 secondes pendant qu'un changement se produit ;
quand rien ne change, le scanner ralentit à 5 secondes avec un abonné connecté
et à 10 secondes sans abonné. `daemon.scan_interval` déplace cette base — minimum
1 s — et les deux plafonds évoluent avec elle, donc l'augmenter à `5s` recule à
12,5 s et 25 s plutôt que de figer la courbe aux anciennes limites.
`daemon.stats_interval` est la cadence distincte à laquelle le processeur, la
mémoire et la charge de l'hôte se rafraîchissent pendant qu'un abonnement est
actif. Les deux sont lus au démarrage du démon : modifiez le fichier, puis
`sonar daemon restart`. `sonar daemon status` affiche les valeurs en
vigueur (`scan base`, `stats tick`) à côté de l'intervalle adaptatif que le
scanner utilise actuellement.

Un abonné qui demande `include: ["health"]` fait sonder par le démon **chaque
port en écoute** à une cadence plus lente, pas seulement les services qui
déclarent un chemin `health:` — ceux-ci sont interrogés à chaque tick et
atteignent chaque abonné, que la santé ait été demandée ou non.

### Configuration

`~/.config/sonar/config.yaml` est facultatif ; les drapeaux ont toujours
priorité.```sh
sonar config path
sonar config init
# check
```
```
# 🚀 Installation

## 📦 Installation via pip

```bash
pip install pyrit
```

## 🛠️ Installation from source

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

## 🐳 Installation via Docker

```bash
docker build -t pyrit .
docker run -it pyrit
```

## 📚 Additional dependencies

Some features require additional dependencies. Install them with:

```bash
pip install pyrit[all]
```

## 🔧 Configuration

PyRIT uses environment variables for configuration. The most important ones are:

- `PYRIT_API_KEY`: Your API key for the target model
- `PYRIT_ENDPOINT`: The endpoint URL for the target model
- `PYRIT_DEPLOYMENT`: The deployment name for the target model

You can set these in a `.env` file or export them in your shell:

```bash
export PYRIT_API_KEY="your-api-key"
export PYRIT_ENDPOINT="https://your-endpoint.openai.azure.com"
export PYRIT_DEPLOYMENT="your-deployment-name"
```

## ✅ Verification

To verify that PyRIT is installed correctly, run:

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

You should see the version number printed to the console.
``````sh
sonar config edit       # open it in $EDITOR
```
```
# 🚀 **Bienvenue sur le dépôt de l'outil de test de pénétration de la plateforme de gestion des vulnérabilités**

## **Aperçu**

Cet outil est conçu pour automatiser le processus de test de pénétration de la plateforme de gestion des vulnérabilités. Il fournit une suite complète de fonctionnalités pour identifier, analyser et signaler les vulnérabilités de sécurité dans votre infrastructure.

## **Fonctionnalités**

- **Analyse automatisée** : Analyse automatiquement les réseaux, les systèmes et les applications pour détecter les vulnérabilités connues.
- **Gestion des vulnérabilités** : Suit et gère les vulnérabilités détectées tout au long de leur cycle de vie.
- **Génération de rapports** : Génère des rapports détaillés sur les vulnérabilités détectées, y compris les recommandations de remédiation.
- **Intégration** : S'intègre de manière transparente aux outils et flux de travail de sécurité existants.
- **Interface conviviale** : Fournit une interface Web intuitive pour une gestion et une visualisation faciles.

## **Installation**

Pour installer l'outil, suivez ces étapes :

1. Clonez le dépôt :
   ```bash
   git clone https://github.com/your-repo/vulnerability-management-platform-pentest-tool.git
   ```
2. Accédez au répertoire du projet :
   ```bash
   cd vulnerability-management-platform-pentest-tool
   ```
3. Installez les dépendances requises :
   ```bash
   pip install -r requirements.txt
   ```

## **Utilisation**

Après l'installation, vous pouvez démarrer l'outil en exécutant :

```bash
python main.py
```

Accédez ensuite à l'interface Web à l'adresse `http://localhost:5000` dans votre navigateur.

## **Configuration**

L'outil peut être configuré via le fichier `config.yaml`. Vous pouvez spécifier les paramètres suivants :

- `scan_targets` : Liste des cibles à analyser.
- `scan_frequency` : Fréquence des analyses (par exemple, quotidienne, hebdomadaire).
- `notification_settings` : Paramètres pour les notifications par e-mail ou Slack.

## **Contribution**

Nous accueillons les contributions de la communauté. Pour contribuer, veuillez suivre ces étapes :

1. Forkez le dépôt.
2. Créez une nouvelle branche pour votre fonctionnalité ou correction de bug.
3. Soumettez une demande de tirage (pull request) avec une description claire de vos modifications.

## **Licence**

Ce projet est sous licence MIT. Voir le fichier `LICENSE` pour plus de détails.

## **Remerciements**

Nous tenons à remercier tous les contributeurs et la communauté open source pour leur soutien et leurs contributions.

---

Pour toute question ou problème, veuillez ouvrir un problème (issue) sur le dépôt GitHub.
``````yaml
list:
  columns: [port, process, group, container, image, containerport, url]
  sort: port            # port | pid | name | type
  filter: ""            # docker | user | system | "" (all)
  all: false            # include desktop apps by default
daemon:
  idle_timeout: 30m     # 0 keeps the daemon running
  log_level: info       # debug | info | warn | error
  scan_interval: 2s     # base port-scan cadence, minimum 1s
  stats_interval: 1s    # cpu/memory refresh while subscribed, minimum 250ms
color: true
services:               # label custom/unknown ports
  9000: php-fpm
  5050: my-dashboard
```
Les valeurs invalides sont ignorées avec un avertissement et sonar continue avec les valeurs par défaut.
Les surcharges d'environnement sans clé de configuration : `SONAR_DB`, `SONAR_SOCKET`,
`SONAR_NO_HINTS=1` pour masquer les avis de migration ci-dessous, et
`SONAR_NO_AUTOSTART=1` pour empêcher tout client sonar de démarrer un démon qu'il n'a
pas trouvé — utile en CI, où une compilation ne doit jamais laisser de processus en arrière-plan.

La suite de tests de sonar définit `SONAR_NO_AUTOSTART=1` pour chaque binaire de test et,
après l'exécution, recherche un démon qui lui a survécu. Cette barrière ne revendique qu'un
`serve` démarré depuis la racine temporaire privée de l'exécution, donc deux suites s'exécutant côte à côte
sur une même machine laissent les démons de l'autre tranquilles ;
`SONAR_TESTENV_GATE_ALL=1` l'élargit à nouveau à chaque `sonar serve` n'importe où sous
le répertoire temporaire, ce qui est ce qu'un exécuteur CI qui possède toute la machine
souhaite.

### Agents : MCP, compétences et hooks```sh
sonar install mcp --claude-code               # merge into <git root>/.mcp.json
sonar install mcp --cursor --scope user       # ~/.cursor/mcp.json
sonar install mcp --codex                     # codex mcp add
sonar install skills --claude-code            # the bundled sonar skill
sonar install hooks --claude-code             # optional, see below
```
I'm ready to translate the Kitploit tool content from English to French. Please provide the Markdown content for chunk 87 of 107.```sh
sonar install mcp --generic --print
sonar install skills --print
sonar install hooks --print
# check
```
`install mcp` enregistre `{"command": "sonar", "args": ["mcp"]}` et laisse chaque
autre serveur et clé du fichier intact ; l'exécuter deux fois ne change rien, et
`--uninstall` supprime exactement ce que sonar a écrit.

`sonar mcp` est ce serveur : un serveur MCP stdio intégré au binaire qui donne
à un agent la vision du démon sur la machine. Il lit avec `list_ports` et
`inspect_port`, attend avec `wait_for_port`, choisit et réserve des ports avec
`next_free_port` et `claim_port`, et répond au reste des questions d'un agent
avec `tail_logs`, `health_check`, `dependency_graph`, `port_history` et
`list_sessions` ; les actions et ressources viennent ensuite. Il démarre un démon
si aucun n'est en cours d'exécution et se reconnecte de lui-même si l'un d'eux
disparaît ; ses journaux vont sur stderr, car stdout transporte le protocole.

`install skills` écrit la compétence fournie, qui apprend à un agent à démarrer
des serveurs avec `sonar start --`, à utiliser `sonar wait` au lieu de dormir, et
à nettoyer ce qu'il a démarré. `install hooks` ajoute deux hooks Claude Code : l'un
exporte `SONAR_SESSION` pour que tout ce qu'une session démarre lui soit attribué,
l'autre suggère `sonar start --` lorsqu'un serveur de développement nu est sur le
point de s'exécuter (il conseille, il ne bloque jamais). Les deux acceptent
`--scope project|user`, `--print` et `--uninstall`.

### `sonar doctor`

Une commande qui vérifie tout ce dont sonar dépend et indique quoi faire face à
ce qui ne va pas. C'est ce que l'application de bureau exécute lors de la prise en
main, et ce qu'il faut exécuter soi-même lorsque quelque chose cloche.```sh
sonar doctor                       # the table, and a one-line verdict
sonar doctor --json                # {ok, checks, version, daemon_version}
sonar doctor --only db_ok,tray     # just these
sonar doctor --only mcp_registered # a whole family
sonar doctor --project ~/code/api  # a project other than the working directory
sonar doctor --fix --yes           # apply the safe repairs, then check again
```
- **`--no-ansi`** : Désactive la sortie ANSI colorée.
- **`--no-color`** : Désactive la sortie colorée.
- **`--no-interaction`** : N’affiche aucune question interactive.
- **`--no-progress`** : Désactive l’affichage de la progression.
- **`--ansi`** : Force la sortie ANSI.
- **`--version`** : Affiche la version de l’application.
- **`--help`** : Affiche l’aide de la commande.
- **`--quiet`** : N’affiche aucun message.
- **`--verbose`** : Augmente la verbosité des messages.```sh
# check
sonar doctor --only daemon_reachable,daemon_protocol,socket_permissions,db_ok
sonar doctor --json --only config_parses | grep -q '"status": "ok"'
sonar doctor --only mcp_registered --project . > /dev/null
```
Chaque vérification renvoie `ok`, `warn`, `fail` ou `skip`. `skip` signifie qu'il n'y avait
rien à examiner — Cursor n'est pas installé, la machine n'a pas docker, la
socket est un named pipe sur Windows — et ne compte jamais contre vous. Le code
de sortie est 0 sauf si quelque chose a **échoué**, donc `sonar doctor` a sa
place dans un script d'installation.

| check | ce que cela signifie |
| --- | --- |
| `cli_on_path` | le binaire que vous avez exécuté est celui que PATH résout ; nomme l'installation qui le masque si ce n'est pas le cas |
| `cli_version_current` | comparé à la dernière version, ou `skip` lorsque GitHub n'est pas joignable en 2s |
| `config_parses` | votre `config.yaml` se charge ; une erreur de syntaxe est signalée avec une ligne, une colonne et un caret |
| `config_dir_writable` | le daemon peut écrire son journal, son verrou et sa base de données |
| `daemon_reachable` | quelque chose écoute sur la socket |
| `daemon_version_matches` | le daemon en cours d'exécution correspond à la version du CLI que vous utilisez |
| `daemon_protocol` | la version majeure du protocole du daemon correspond à celle de cette build |
| `socket_permissions` | la socket vous appartient et est en 0600, dans un répertoire 0700 (`skip` sur Windows) |
| `db_ok` | la base de données s'ouvre, est au schéma le plus récent, et sa taille |
| `mcp_registered.{claude_code,cursor,codex}` | le serveur MCP de sonar est dans la config de ce client |
| `skills_installed` | la compétence fournie est installée et à jour |
| `hooks_installed` | les hooks optionnels Claude Code sont installés |
| `project_config` | ce projet a un `.sonar.yaml` qui se charge |
| `docker` | le CLI docker est présent et son daemon répond |
| `desktop_installed` | l'application de bureau est installée, et quelle version (`skip` sur Windows) |
| `tray` | l'ancien binaire macOS `sonar-tray` est toujours présent |

`--fix` n'applique que les réparations sûres à faire sans surveillance, et
demande d'abord sauf si vous passez `--yes` : il déplace un `config.yaml`
illisible vers `config.yaml.broken-<timestamp>` et écrit un nouveau modèle
(rien n'est jamais supprimé), redémarre un daemon qui ne tourne pas, et exécute
la commande `sonar install mcp|skills|hooks` nommée par la vérification — depuis
le répertoire de travail, comme vous la taperiez, donc lancez `--fix` dans le
projet que vous réparez plutôt que de pointer `--project` dessus. Puis il
revérifie. Tout ce qu'il ne touchera pas — un binaire qui masque sur PATH, une
compétence que sonar n'a pas écrite — vous est laissé avec la commande exacte
dans la colonne `fix`.

L'application de bureau appelle les mêmes vérifications via la méthode
`daemon.doctor` du daemon au lieu de passer par un shell. Le daemon exécute
tout ce qu'il peut depuis son propre processus ; les trois vérifications qui
concernent le binaire CLI que vous avez invoqué (`cli_on_path`,
`cli_version_current`, `daemon_version_matches`) reviennent en `skip` avec un
détail l'indiquant.

### L'application de bureau

L'application Sonar est la même image dans une fenêtre et dans la barre de menu
ou la zone de notification système : des groupes sur le côté, des ports dans une
grille avec des statistiques en direct et l'état de santé, des journaux, et les
boutons pour tout ce qui précède. Elle communique avec le même daemon, donc le
CLI et l'application ne sont jamais en désaccord. `sonar install desktop`
l'installe et `sonar tray` la lance.

Jusqu'à ce que l'application soit publiée, les archives de version macOS
contiennent encore l'ancien binaire de barre de menu `sonar-tray`, et `sonar
tray` y revient en secours lorsque l'application n'est pas installée.

### `sonar install desktop`

L'application est en bêta et n'est pas encore signée par Apple, donc le CLI
l'installe :```sh
brew install raskrebs/sonar/sonar && sonar install desktop
```
Voilà l'ensemble du dispositif de test. Sonar récupère un manifeste des builds publiés,
sélectionne celui correspondant à votre machine, vérifie son sha256 et sa taille,
l'installe, puis l'ouvre.

**C'est pourquoi la CLI effectue le téléchargement.** macOS appose un attribut de
quarantaine à tout ce qu'un *navigateur* enregistre, et Gatekeeper refuse d'ouvrir une
application en quarantaine qu'Apple n'a pas notarisée. Un fichier téléchargé par cette CLI
ne reçoit jamais l'attribut en premier lieu, donc la bêta s'ouvre sans invite ni
manipulation de clic droit-Ouvrir. Sonar ne définit ni ne supprime les attributs de quarantaine —
il n'y a rien à supprimer.```sh
sonar install desktop                    # install and launch
sonar install desktop --no-launch        # install only
sonar install desktop --update           # update; does nothing if current
sonar install desktop --check            # exit 1 when an update is available
sonar install desktop --version 0.1.0-beta.1
sonar install desktop --force            # ask a running Sonar to quit first
sonar install desktop --json             # for scripts
```
La commande n'a pas besoin de réseau pour vous dire ce qu'elle fait :```sh
sonar install desktop --help | grep -- '--no-launch'
# check
```
Où il est installé :

| | |
| --- | --- |
| macOS | `/Applications/Sonar.app`, ou `~/Applications/Sonar.app` lorsque le premier n'est pas accessible en écriture (sonar n'utilise jamais `sudo`) |
| Linux | `~/.local/opt/sonar-desktop/Sonar.AppImage`, plus une entrée de menu dans `~/.local/share/applications` et un lien `sonar-desktop` dans `~/.local/bin` |
| Windows | pas encore — la commande le signale et se termine avec le code 1 |

`--dir` remplace le répertoire sur les deux. Sous Linux, `--deb` installe le `.deb`
via `apt`/`dpkg` au lieu de l'AppImage, lorsque la version en publie un.

L'installation est atomique : la nouvelle application est décompressée à côté de l'ancienne puis échangée
par un renommage, de sorte qu'un téléchargement échoué ne vous laisse jamais sans application fonctionnelle.
Si l'application est ouverte, sonar refuse plutôt que de remplacer un bundle en cours d'utilisation ;
`--force` lui demande de quitter et attend jusqu'à dix secondes.

`sonar install desktop` enregistre `desktop.installed_version` et
`desktop.installed_path` dans `~/.config/sonar/config.yaml`, ce qui permet à `sonar
tray` de trouver une application installée avec `--dir` et au contrôle
`desktop_installed` de `sonar doctor` de connaître la version. L'origine des builds est
`desktop.download_base`, remplacée par `SONAR_DESKTOP_BASE` puis par
`--base` — pointez-les vers votre propre build pour en tester un.

### `sonar relay`

Le relay est le côté serveur de sonar : un petit service HTTP, exploité par nos soins pour
l'application hébergée et publié sous `ghcr.io/raskrebs/sonar-relay` afin que vous puissiez en
exécuter un vôtre. Il n'a rien à voir avec le démon local — `sonar serve` surveille
vos ports, `sonar relay serve` répond en HTTP pour une flotte — et il est fourni dans le
même binaire uniquement pour qu'il n'y ait qu'un seul artefact à déployer.

Aujourd'hui, il collecte des données de télémétrie anonymes sur les produits : un lot d'événements nommés par
installation, sans chemins, sans noms d'hôtes, sans URL, refusés à l'entrée si une valeur en a
même l'apparence. C'est le même service qui, plus tard, terminera les tunnels exposés
et gérera la connexion.```sh
sonar relay serve --db ./relay.db --project-keys "$(openssl rand -hex 24)"
```
`docs/RELAY.md` contient les routes, les règles de validation exactes, le schéma de stockage
et un déploiement en une commande derrière Caddy sur n'importe quelle machine avec Docker.

## Migration depuis les anciennes commandes

Les commandes pré-groupes fonctionnent toujours et affichent une seule ligne sur stderr indiquant ce qui
les a remplacées. Elles disparaîtront dans une prochaine version mineure. `SONAR_NO_HINTS=1`
masque les notifications, et la sortie `--json` ne les inclut jamais.

| Ancien | Nouveau |
|---|---|
| `sonar run --tag X -- cmd` | `sonar start --group X -- cmd` |
| `sonar runs` | `sonar start --list` |
| `sonar list --tag X` | `sonar list --group X` |
| `sonar kill-all --filter docker` | `sonar kill --all --filter docker` |
| `sonar down X` | `sonar kill -g X` |
| `sonar profile create X` | `sonar init` |
| `sonar profile show X` | `sonar groups X` |
| `sonar up X` (vérifiait un profil) | `sonar up X` *démarre* désormais le groupe |
| `sonar tray` (app de barre de menus Swift) | `sonar tray` lance l'application de bureau |

Les profils étaient un instantané des ports propre à chaque machine ; `.sonar.yaml` est versionné avec
le projet. Convertissez-en un et lisez-le avant de le conserver — rien n'est écrit pour vous :```sh
sonar profile list
# check
```
(empty)```sh
sonar profile export my-app > .sonar.yaml
```
Un profil n’a jamais enregistré la façon dont un service démarre, donc la proposition contient des ports, des noms et des chemins de santé, et vous remplissez `cmd`.

## Dépannage

**Quelque chose ne va pas avec le démon.** `sonar daemon log -f` pendant que vous reproduisez le problème, et `sonar daemon status` pour le pid, la durée de fonctionnement et le nombre d’analyses. Arrêtez-le avec `sonar daemon stop` ; chaque commande de lecture continue de fonctionner sans lui.

**« daemon unavailable, using direct scan ».** Rien n’écoute sur le socket. C’est normal — les lectures ne démarrent pas un démon. Exécutez `sonar serve -d` si vous en voulez un.

**Un socket laissé après un crash.** `sonar daemon path` l’affiche ; démarrer un démon supprime tout seul un socket obsolète. Si un second démon refuse de démarrer alors que le premier a disparu, `sonar daemon restart` efface le verrou.

**Des ports manquent dans la liste.** Les processus appartenant à un autre utilisateur sont invisibles sans privilèges ; sonar l’indique sous le tableau. Relancez avec `sudo sonar list` pour les voir. Sous Linux, `ss` doit être installé (`iproute2`) ; sous Windows, `netstat` est utilisé.

**Un kill n’a rien fait.** Les conteneurs Docker sont arrêtés via le démon Docker : vérifiez `docker ps`. Un processus qui ignore SIGTERM nécessite `-f`, et un processus supervisé par autre chose (systemd, Compose `restart: always`) revient par conception — arrêtez le superviseur.

**Rien ne fonctionne et vous ne savez pas pourquoi.** `sonar doctor` vérifie le binaire, la configuration, le démon, la base de données et chaque intégration en une seule fois, et affiche la commande qui corrige chaque élément trouvé.

**Signaler un bug.** Incluez ces éléments, ainsi que les dernières lignes de `sonar daemon log` :```sh
sonar version
sonar daemon status
sonar doctor --json
# check
```
## Plateformes prises en charge

- macOS (utilise `lsof`)
- Linux (utilise `ss`)
- Windows (utilise `netstat`)

Le regroupement nécessite le répertoire de travail de chaque processus, et chaque plateforme en dispose désormais
d'un : `/proc` sur Linux, `lsof` sur macOS, et sur Windows une lecture du
PEB propre au processus. Ainsi, les groupes racine-git, `project_root` et les noms basés sur le répertoire de travail fonctionnent de la même manière
partout, et `sonar init` peut proposer un `.sonar.yaml` à partir de ce qui écoute
sur l'une des trois plateformes.

L'application de bureau est plus limitée pour l'instant : `sonar install desktop` l'installe sur
macOS (Apple Silicon et Intel) et Linux (x86_64 et aarch64). Sur Windows, la
commande indique que l'application n'est pas encore disponible et se termine avec le code 1.

La seule lacune est un `sonar.exe` 32 bits sur Windows 64 bits : il ne peut pas lire la mémoire d'un processus
64 bits, donc ces ports reviennent sans répertoire de travail et sortent
de leur groupe racine-git. Utilisez la version 64 bits — elle lit les processus 64 bits et 32 bits
indifféremment. Ailleurs, un port dont le processus refuse l'accès (un service
exécuté sous un autre utilisateur, un processus système protégé) est simplement laissé sans
répertoire de travail ; le reste de l'analyse n'est pas affecté.

## Contributeurs

Merci à tous ceux qui ont contribué à sonar !

<a href="https://github.com/RasKrebs/sonar/graphs/contributors">
  <img src="https://stg.contrib.rocks/image?repo=RasKrebs/sonar" />
</a>