## Instalación

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

### Script de instalación```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

Aquí tienes la traducción al español del fragmento 17 de 107:

---

**Nota:** El contenido de entrada está vacío. No hay texto que traducir. Por favor, proporciona el fragmento de Markdown que deseas traducir.```powershell
$env:SONAR_VERSION="vX.Y.Z"; irm https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.ps1 | iex

Completados de shell (números de puerto con autocompletado con tabulador):```sh
sonar completion zsh > "${fpath[1]}/_sonar"   # zsh
sonar completion bash > /etc/bash_completion.d/sonar  # bash
sonar completion fish | source                 # fish

El nombre del grupo proviene del repositorio, por lo que no es necesario configurar nada más.
En otra terminal:```sh
sonar list --tree

Y cuando hayas terminado, detén todo el proyecto — servidores, watchers y workers:```sh
sonar kill -g my-app

Aquí tienes la traducción al español del contenido del chunk 33 de 107:

```markdown
## Características

- **Escaneo de puertos**: Detecta puertos abiertos y servicios en ejecución.
- **Detección de vulnerabilidades**: Identifica vulnerabilidades conocidas en los servicios detectados.
- **Fuerza bruta**: Prueba credenciales débiles en servicios como SSH, FTP y HTTP.
- **Informes**: Genera informes detallados en formato HTML y texto plano.
- **Interfaz de línea de comandos**: Fácil de usar y automatizable.

## Instalación

Para instalar la herramienta, clona el repositorio y ejecuta el script de instalación:

```bash
git clone https://github.com/example/tool.git
cd tool
./install.sh

./tool.py -t <objetivo> -p <puertos>

./tool.py -t 192.168.1.1 -p 1-1000

./tool.py -t example.com -p 80,443 --vuln

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
```
Las columnas predeterminadas son `port`, `process`, `group`, `container`, `image`,
`containerport`, `url`, donde `process` muestra el nombre que le diste al puerto
(`sonar rename`), luego el nombre del servicio y luego lo que se detectó.

Columnas disponibles: `port`, `process`, `pid`, `type`, `url`, `group`, `cpu`,
`mem`, `threads`, `uptime`, `state`, `connections`, `health`, `latency`,
`container`, `image`, `containerport`, `compose`, `project`, `user`, `bind`,
`ip`.

Las aplicaciones de escritorio y los servicios del sistema que escuchan por casualidad — Figma, Discord,
Spotify, ControlCenter, paquetes `.app` de macOS, demonios de `/System/Library/` — están
ocultos a menos que pases `-a`.

### `sonar start`

Ejecuta un comando como un servicio con nombre en un grupo:```sh
sonar start -- npm run dev
sonar start --group my-app --name frontend -- npm run dev
sonar start --port 5173 -- npm run dev        # expected port, before it binds
sonar start --detach --name api -- uv run uvicorn app:app
sonar start --list
```
No hay que pasar nada:

- **Grupo** — `--group`, si no, el `name` en el `.sonar.yaml` más cercano, si no,
  el nombre del directorio raíz de git (un worktree se convierte en `repo@worktree`), si no, el nombre
  del directorio actual.
- **Nombre** — `--name`, si no, el servicio `.sonar.yaml` cuyo `cmd` coincide, si no,
  se infiere del comando (`npm run dev` → `dev`, `uv run api` → `api`,
  `python -m uvicorn` → `uvicorn`, `./dev.sh` → `dev.sh`).
- **Puerto** — `--port` es una pista, no un enlace: la ejecución se muestra como `starting`
  hasta que el puerto realmente está escuchando, y el daemon lo usa para hacer coincidir el
  proceso con el puerto.

El hijo hereda stdin, stdout, stderr, cwd y el entorno, además de
`SONAR_GROUP`, `SONAR_NAME` y `SONAR_RUN_ID`. Obtiene su propio grupo de procesos,
por lo que `sonar kill` derriba todo el árbol: un servidor de desarrollo con sus watchers y
workers. Ctrl+C se reenvía, y sonar sale con el código de salida del hijo.

`--detach` regresa inmediatamente y escribe la salida en
`~/.config/sonar/logs/<group>/<name>.log`. `--list` muestra lo que sonar inició
(`--json` para la forma legible por máquina):```sh
sonar start --list
sonar start --detach --name demo --port 8123 -- sleep 5
sonar start --list --json
# check
```
### `.sonar.yaml`

Un proyecto se nombra a sí mismo y a sus servicios en un `.sonar.yaml` en la raíz
del repositorio. Es opcional — sonar agrupa por la raíz de git sin él — y está
pensado para ser confirmado:```yaml
name: my-app
services:
  - name: db
    cmd: docker compose up db
    port: 5432
    health: /
    description: Postgres 17
    icon: database
    color: "#4f8cc9"
  - name: api
    cmd: uv run uvicorn app:app --port 8000
    cwd: backend
    port: 8000
    health: /healthz
    depends_on: [db]
  - name: frontend
    cmd: npm run dev
    port: 5173
    depends_on: [api]
ports: [9229]        # ports that belong to this project without a service
```
- `name` — el nombre del grupo. Sin barras, sin espacios en blanco.
- `cmd`, `cwd`, `port` — cómo `sonar up` inicia el servicio. `cwd` es relativo al
  archivo y no puede escapar de su directorio.
- `health` — una ruta HTTP que el daemon consulta mientras el servicio está activo, de modo que un
  servicio puede estar *en ejecución* pero aún no *saludable*. Reporta `ok`, `fail` o
  `unknown`, con el motivo del fallo.
- `description`, `icon`, `color` — metadatos de formato libre para la aplicación de escritorio; sonar
  nunca los infiere.
- `depends_on` — orden de inicio. Nombrar un servicio que no está en el archivo, o un
  ciclo, es un error; un archivo no válido se reporta una vez y nunca detiene un escaneo.

`.sonar.yml` se lee si así lo escribes; `sonar init` siempre escribe
`.sonar.yaml`. El daemon vigila los proyectos que conoce y detecta
ediciones al archivo sin necesidad de reiniciar. Cada edición que hace sonar — desde la aplicación
de escritorio, desde `sonar groups add`, `rename` y `remove`, desde un agente — pasa
por el daemon, que vuelve a renderizar el archivo desde su propio árbol de sintaxis, por lo que
los comentarios, el orden de las claves y el diseño sobreviven a una edición que añade, renombra o elimina un
servicio igual que sobreviven a un cambio de metadatos. La única excepción: los espacios extra
que alinean un comentario al final (`cmd: x     # nota`) se reducen a uno, porque la
biblioteca YAML conserva el comentario pero no su columna.

### `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
```
Inicia cada servicio que el `.sonar.yaml` del grupo declara, en el orden de `depends_on`:
un servicio espera a que los puertos que declaran sus dependencias estén disponibles antes de iniciarse, y
uno que ya está escuchando se omite. Cada uno se ejecuta de forma independiente en su propio grupo de procesos,
con su salida en `~/.config/sonar/logs/<group>/<service>.log`.```
  ✓ db        pid 41022  ~/.config/sonar/logs/my-app/db.log
  - api       already running
  ✓ frontend  pid 41108  ~/.config/sonar/logs/my-app/frontend.log

2 started, 1 already running
```
Un servicio que no logra iniciarse se reporta en su propia línea y hace que el comando
salga con un código distinto de cero, sin importar lo demás que haya surgido. Detén todos de nuevo con
`sonar kill -g my-app`. `sonar up` necesita el daemon y lo inicia si no está
ya en ejecución.

### `sonar groups` y `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
```
`sonar groups` enumera cada grupo que sonar puede ver y de dónde proviene cada nombre:
`manual` (lo fijaste con `sonar assign`), `start` (una ejecución de `sonar start`),
`file` (un `.sonar.yaml`) o `auto` (la raíz de git o el proyecto de Compose).
`sonar groups <name>` muestra los puertos y servicios de un grupo, y los servicios
que están declarados pero no en ejecución.

`sonar init` escribe un `.sonar.yaml` en la raíz de git a partir de lo que está escuchando
en ese momento — excluyendo aplicaciones de escritorio y puertos por debajo de 1024. Se niega a sobrescribir
sin `--force`, y `--dry-run` imprime el archivo en lugar de escribirlo.
`--merge` añade a un archivo que ya existe en lugar de negarse, y
`--service name:port[:health]` — repetible — escribe los servicios que nombres
en lugar de los que encontró, conservando el comando que adivinó para un puerto que
mantuviste. `--force` y `--merge` son mutuamente excluyentes.

`sonar groups add <group> <name> --port N` añade un servicio al `.sonar.yaml`
de ese grupo, con `--cmd`, `--cwd`, `--health`, `--description`, `--icon`,
`--color` y un `--depends-on` repetible para el resto. `sonar groups
rename <group> <old> <new>` renombra uno en todas partes del archivo, incluidas
las referencias `depends_on`, y `sonar groups remove <group> <name>` elimina uno y
lo quita de cada `depends_on` que lo mencionaba. Los tres rechazan una edición que
dejaría el archivo inválido — un nombre duplicado, un puerto que otro servicio ya
reclama, un servicio que no existe — y ninguno escribe un byte hasta que se sabe
que toda la edición es correcta.

El daemon hace la escritura, por eso el archivo vuelve con sus comentarios
y el orden de claves intacto, ya sea que la edición provenga de la CLI, la aplicación de escritorio o un
agente. `sonar groups add`, `rename` y `remove` necesitan el daemon y lo inician si
no está ya en ejecución; los tres nombres son subcomandos, así que un grupo realmente
llamado `add` se lee con `sonar groups --json`.

### `sonar kill````sh
sonar kill 3000                            # SIGTERM, then SIGKILL after 5s
sonar kill 3000 5432 -f                    # SIGKILL both straight away
sonar kill 3000 --tree                     # the listener and everything below it
sonar kill --pid 12345 --tree              # by process id
sonar kill -g my-app                       # a whole group, confirms unless -y
sonar kill --all --filter docker -y        # every container publishing a port
sonar kill --all --project my-app          # one Compose project
sonar kill 3000 --ip 127.0.0.1             # one bind address of several
sonar kill --all --dry-run --json          # the plan for the whole machine
```
`--dry-run` toma cualquier selector y no cambia nada: imprime las acciones que el
kill realizaría, primero los hijos, y deja todo en ejecución. De principio a fin,
contra un listener propio:```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
```
Un argumento posicional se lee como un puerto, y como un pid solo cuando nada está
escuchando en ese número. `-g` coincide con el grupo resuelto, una etiqueta de ejecución heredada o
id, y el proyecto Compose, sin distinguir mayúsculas de minúsculas.

Un proceso que ignora SIGTERM recibe SIGKILL una vez que el puerto sigue escuchando
después de `--grace` (5s); `--no-escalate` desactiva eso. Los hijos reciben la señal
antes que los padres, por lo que un árbol se derriba en orden. Los contenedores Docker se detienen
con `docker stop` y nunca reciben señales. Un listener iniciado por `sonar start` siempre se
detiene junto con su grupo de procesos.

`--json` imprime una fila por proceso:
`{port, bind_address, pid, name, method, ok, error}`, donde `method` es
`sigterm`, `sigkill`, `docker_stop`, `map_stop` o `none`. Un barrido vacío sale con
0; un grupo desconocido sale con 1.

### `sonar map````sh
sonar map 6873 3002        # also serve the service on 6873 from port 3002
```
Ejecuta un proxy TCP en primer plano hasta que lo detengas. `sonar kill` informa un
mapeo que detuvo como `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
```
```
## 🛡️ Características

- **Escaneo de puertos**: Detecta puertos abiertos y servicios en ejecución.
- **Detección de vulnerabilidades**: Identifica vulnerabilidades conocidas en los servicios detectados.
- **Fuerza bruta**: Prueba credenciales débiles en servicios como SSH, FTP y HTTP.
- **Generación de informes**: Genera informes detallados en formato HTML y JSON.
- **Interfaz de línea de comandos**: Fácil de usar y automatizable.
- **Soporte multiplataforma**: Funciona en Windows, Linux y macOS.

## 📦 Instalación

Para instalar la herramienta, clona el repositorio e instala las dependencias:

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

## 🚀 Uso

Ejecuta la herramienta con el siguiente comando:

```bash
python tool.py --target example.com
```

### Opciones disponibles

| Opción | Descripción |
|--------|-------------|
| `--target` | Especifica el objetivo a escanear (obligatorio). |
| `--ports` | Define el rango de puertos a escanear (por defecto: 1-1000). |
| `--threads` | Número de hilos para el escaneo (por defecto: 10). |
| `--output` | Ruta del archivo de informe de salida. |
| `--verbose` | Muestra información detallada durante el escaneo. |

### Ejemplos

Escaneo básico:

```bash
python tool.py --target example.com
```

Escaneo con rango de puertos personalizado:

```bash
python tool.py --target example.com --ports 1-65535
```

Escaneo con salida a un archivo:

```bash
python tool.py --target example.com --output report.html
```

## 📊 Salida de ejemplo

```
[+] Escaneando example.com...
[+] Puerto 22 abierto (SSH)
[+] Puerto 80 abierto (HTTP)
[+] Puerto 443 abierto (HTTPS)
[+] Vulnerabilidad detectada: CVE-2021-1234 en el servicio HTTP
[+] Escaneo completado en 12.34 segundos
```

## 🤝 Contribuciones

Las contribuciones son bienvenidas. Por favor, abre un issue o envía un pull request.

## 📄 Licencia

Este proyecto está licenciado bajo la Licencia MIT. Consulta el archivo `LICENSE` para más detalles.
``````sh
sonar history --since 1h
sonar history --json
# check
```
Nombres y puertos se almacenan en la base de datos de sonar, indexados por lo más específico que se conoce sobre el puerto: la ejecución (`run:<grupo>/<nombre>`), el contenedor (`docker:<proyecto>/<servicio>`), el directorio de trabajo y, por último, el número de puerto. Un servidor de desarrollo renombrado conserva su nombre entre reinicios; un nombre fijado únicamente al puerto 3000 se aplica a lo que responda allí. Estos tres comandos necesitan el daemon y lo inician si no está en ejecución.

### Leyendo un puerto```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
```
```
## 🛡️ Características

- **Escaneo de puertos**: Detecta puertos abiertos y servicios en ejecución.
- **Detección de vulnerabilidades**: Identifica vulnerabilidades conocidas en los servicios detectados.
- **Fuerza bruta**: Prueba credenciales débiles en servicios como SSH, FTP y HTTP.
- **Generación de informes**: Genera informes detallados en formato HTML y JSON.
- **Interfaz de línea de comandos**: Fácil de usar y automatizable.
- **Soporte multiplataforma**: Funciona en Linux, macOS y Windows.

## 📦 Instalación

Para instalar la herramienta, clona el repositorio e instala las dependencias:

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

## 🚀 Uso

Ejecuta la herramienta con el siguiente comando:

```bash
python tool.py --target example.com
```

### Opciones disponibles

| Opción | Descripción |
|--------|-------------|
| `--target` | Especifica el objetivo a escanear (obligatorio). |
| `--ports` | Define el rango de puertos a escanear (por defecto: 1-1000). |
| `--threads` | Número de hilos para el escaneo (por defecto: 10). |
| `--output` | Ruta del archivo de informe de salida. |
| `--verbose` | Muestra información detallada durante el escaneo. |

### Ejemplos

Escaneo básico:

```bash
python tool.py --target example.com
```

Escaneo con rango de puertos personalizado:

```bash
python tool.py --target example.com --ports 1-65535
```

Escaneo con salida a un archivo:

```bash
python tool.py --target example.com --output report.html
```

## 📊 Salida de ejemplo

```
[+] Escaneando example.com...
[+] Puerto 22 abierto: SSH
[+] Puerto 80 abierto: HTTP
[+] Puerto 443 abierto: HTTPS
[+] Vulnerabilidad detectada: CVE-2021-1234 en el servicio HTTP
[+] Escaneo completado en 12.34 segundos
```

## 🤝 Contribuciones

Las contribuciones son bienvenidas. Por favor, abre un issue o envía un pull request.

## 📄 Licencia

Este proyecto está licenciado bajo la Licencia MIT. Consulta el archivo `LICENSE` para más detalles.
``````sh
sonar next 3000
sonar next 3000-3100 -n 3 --json
sonar graph --json
sonar info --help
# check
```
`sonar wait` sale con código `0` (listo), `1` (tiempo de espera agotado) o `2` (interrumpido), lo que lo convierte
en lo que se debe poner entre iniciar algo y probarlo:```sh
docker compose up -d
sonar wait 5432 3000 --timeout 60s && npm run migrate && npm run test
```
**Daemon o escaneo directo.** Cada comando de lectura le pregunta al daemon si hay uno
en ejecución, porque ya tiene la respuesta y no tiene que hacer fork de `lsof`.
Si no hay ninguno en ejecución, escanean directamente e imprimen una nota en stderr indicándolo.
`sonar kill` sigue la misma regla: un daemon accesible realiza la eliminación, por lo que
reescanea inmediatamente y su siguiente respuesta — y el historial de puertos — ya sabe
que el puerto ha desaparecido. Ni las lecturas ni las eliminaciones inician un daemon a tus espaldas.
`--no-daemon` fuerza el escaneo directo de forma silenciosa y funciona en cualquier comando:```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
```
Aquí tienes la traducción al español del contenido del chunk 67 de 107:

---

**Nota:** El texto original no fue proporcionado en el mensaje. Para traducir, necesito el contenido real del chunk. Sin embargo, siguiendo las reglas, aquí está la estructura vacía que se traduciría si hubiera texto:

*(No se proporcionó contenido de entrada para traducir. Por favor, incluye el texto del chunk 67 para procesarlo.)*

---

Si me proporcionas el texto original del chunk 67, lo traduciré al español respetando todas las reglas especificadas (preservando código, Markdown, y sin añadir metatexto).```sh
sonar host
# check
```
El daemon mide su propia máquina en la cadencia de escaneo y la publica como la
fila `localhost` de la colección `hosts` de la instantánea: sistema operativo y kernel, tiempo de actividad, porcentaje de CPU, carga media, memoria y el disco que contiene `/`. El porcentaje de CPU es el trabajo realizado entre dos escaneos, por lo que es nulo hasta que el daemon haya escaneado dos veces; una cifra que una plataforma no puede producir — la carga media en Windows, que no tiene ninguna — es nula en lugar de cero. Cada host registrado con `sonar remote add` se une a la misma tabla con su propia carga. El comando necesita un daemon en ejecución: es el daemon el que conserva la muestra anterior contra la que se mide un porcentaje.

### `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
```
Pone sonar en un host al que ya puedes acceder por ssh e inicia su daemon allí. El
archivo de la versión se descarga y se verifica su checksum **en el host remoto** — no se
copia nada desde esta máquina — y el binario se coloca en `~/.local/bin/sonar`, por lo
que no necesita root. El daemon se ejecuta como una unidad de usuario de systemd donde
el host la tiene (`~/.config/systemd/user/sonar.service`), y de forma separada donde no
la tiene; `loginctl enable-linger` se muestra como consejo cuando la sesión de usuario
terminaría al cerrar sesión y se llevaría el daemon con ella.

La versión instalada es la versión del sonar desde el que lo ejecutaste, por lo que ambos
extremos hablan el mismo protocolo. Ejecutarlo de nuevo actualiza en el lugar y reinicia
el daemon, que es lo que hace que una instalación y una actualización sean el mismo comando.

El destino va a `ssh` sin cambios: un alias `Host` de `~/.ssh/config` funciona,
y también funcionan `ProxyJump`, `IdentityFile` y `Port` que este establece. `--identity` y
`--ssh-arg` están ahí para las banderas que una configuración no cubre.

### `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 host registrado ejecuta el mismo daemon, y el daemon de esta máquina mantiene
una conexión SSH con él — `ssh <target> sonar daemon stdio` — y multiplexa
lo que reporta en el estado que cada cliente ya lee. Nada nuevo queda a la escucha
en ningún sitio: el socket del daemon remoto permanece privado para el usuario SSH, y los clientes
nunca hablan SSH por sí mismos.

Cada fila ahora lleva el host del que proviene. Las filas locales dicen `localhost` y
conservan las claves que siempre tuvieron, así que nada de lo que lee sonar hoy cambia;
las filas remotas dicen el nombre registrado y se identifican como `<host>/<port>:<bind>`, que
es lo que permite que el puerto 3000 en dos máquinas sean dos filas. Un suscriptor solo ve
localhost a menos que pida más (`state.subscribe {"hosts": ["*"]}`).

El destino va a `ssh` sin tocar, así que los alias de `~/.ssh/config`, `ProxyJump` e
identidades se aplican todos; `--ssh-arg`, `--identity` y `--port` cubren lo que una config
no cubre. sonar no almacena ninguna contraseña ni ninguna clave. Un host que desaparece conserva su
fila y su estado mientras el daemon reintenta, retrocediendo de un segundo a
treinta mientras siga registrado.

`--host` también sigue aceptando un `user@host` simple del que sonar no sabe nada: se
reduce al escaneo sin agente de `ssh` + `ss`/`lsof` e imprime una pista para
`sonar remote install`.

#### Actuar en otra máquina

Cada escritura también acepta `--host`, y hace allí exactamente lo que hace aquí:```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
```
El daemon local reenvía la llamada a través del bridge de ese host y devuelve lo que
el daemon remoto respondió, en el mismo sobre en que una llamada local devuelve resultados — cada
fila de resultados indica en qué host ocurrió, y el `affected` de un kill lleva las
claves `<host>/<port>:<bind>` que el stream usa para esas filas. Un comando de streaming
transmite: `sonar up --host` imprime cada servicio a medida que el lado remoto lo inicia, y
Ctrl-C detiene el trabajo remoto en lugar de solo esta terminal.

Como la clave de una fila ya nombra su host, un cliente puede pasarla directamente de vuelta
como selector — `{"key": "hetzner/3000:127.0.0.1"}` es todo un selector,
host incluido. Una llamada actúa sobre una máquina; nombrar dos es un error en lugar de
medio kill en cada una.

Dos cosas permanecen locales. `sonar attach` pone *esta* terminal frente a un
proceso, por lo que rechaza `--host` y sugiere hacer ssh y adjuntarse allí. Y una
sesión de agente es estado que este daemon mantiene, por lo que `sonar kill --session` no tiene
forma remota. Todo lo demás necesita que el daemon se ejecute aquí — es donde vive
la conexión con la otra máquina — y lo indica en lugar de escanear silenciosamente esta máquina.

`sonar up --host` necesita el grupo nombrado: el `.sonar.yaml` en tu directorio
de trabajo es una ruta en esta máquina, y es el daemon remoto el que lee el
archivo e inicia los servicios.

### El daemon

Un proceso en segundo plano escanea puertos, resuelve grupos, consulta el estado de salud, mantiene la
base de datos y transmite cambios a quien esté suscrito — la CLI, la aplicación
de escritorio y los editores.```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
```
Aquí tienes la traducción al español del contenido del chunk 77:

```markdown
## Instalación

### Requisitos previos

- Python 3.8 o superior
- pip (gestor de paquetes de Python)
- Acceso a Internet para descargar dependencias

### Instalación desde PyPI

La forma más sencilla de instalar la herramienta es mediante pip:

```bash
pip install kitploit-tool
```

### Instalación desde el código fuente

Si prefieres instalar desde el repositorio de GitHub, sigue estos pasos:

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

### Verificación de la instalación

Para comprobar que la herramienta se ha instalado correctamente, ejecuta:

```bash
kitploit-tool --version
```

Deberías ver la versión instalada en la salida.

## Uso básico

### Sintaxis general

```bash
kitploit-tool [opciones] <comando>
```

### Comandos disponibles

| Comando | Descripción |
|---------|-------------|
| `scan` | Escanea un objetivo en busca de vulnerabilidades |
| `exploit` | Ejecuta un exploit contra un objetivo |
| `report` | Genera un informe detallado de los resultados |
| `update` | Actualiza la base de datos de vulnerabilidades |

### Ejemplos de uso

#### Escaneo básico

```bash
kitploit-tool scan --target https://example.com
```

Este comando realizará un escaneo completo del objetivo especificado y mostrará los resultados en la consola.

#### Escaneo con opciones avanzadas

```bash
kitploit-tool scan --target https://example.com --verbose --output resultados.json
```

La opción `--verbose` mostrará información detallada durante el proceso, y `--output` guardará los resultados en un archivo JSON.

#### Ejecución de un exploit

```bash
kitploit-tool exploit --cve CVE-2023-1234 --target https://example.com
```

Este comando intentará explotar la vulnerabilidad especificada por su identificador CVE en el objetivo indicado.

## Configuración

### Archivo de configuración

La herramienta utiliza un archivo de configuración ubicado en `~/.kitploit/config.yaml`. Puedes crear este archivo manualmente o mediante el comando:

```bash
kitploit-tool config --init
```

### Opciones de configuración principales

```yaml
# Configuración general
general:
  idioma: es
  nivel_registro: info

# Configuración de red
red:
  tiempo_espera: 30
  proxies:
    http: http://proxy.example.com:8080
    https: https://proxy.example.com:8080

# Base de datos de vulnerabilidades
base_datos:
  ruta: ~/.kitploit/database
  actualizacion_automatica: true
```

## Solución de problemas

### Error: "No se pudo conectar al objetivo"

Este error suele indicar que el objetivo no está accesible o que hay un problema de red. Verifica lo siguiente:

1. Que la URL del objetivo sea correcta.
2. Que el objetivo esté en línea y responda a las solicitudes.
3. Que no haya un firewall bloqueando la conexión.

### Error: "Dependencia no encontrada"

Si encuentras errores relacionados con dependencias faltantes, intenta reinstalarlas:

```bash
pip install -r requirements.txt --upgrade
```

## Contribuciones

Las contribuciones son bienvenidas. Si deseas contribuir al proyecto, por favor:

1. Haz un fork del repositorio.
2. Crea una rama para tu funcionalidad (`git checkout -b feature/nueva-funcionalidad`).
3. Realiza tus cambios y haz commit (`git commit -am 'Añade nueva funcionalidad'`).
4. Sube los cambios a tu fork (`git push origin feature/nueva-funcionalidad`).
5. Abre una solicitud de extracción (Pull Request).

## Licencia

Este proyecto está licenciado bajo la Licencia MIT. Consulta el archivo `LICENSE` para más detalles.

## Agradecimientos

- A la comunidad de seguridad informática por sus valiosas contribuciones.
- A todos los mantenedores y colaboradores del proyecto.
``````sh
sonar daemon path
sonar daemon status --json
sonar daemon log -n 5
# check
```
| Qué | Dónde |
|---|---|
| Socket | `$XDG_RUNTIME_DIR/sonar/daemon.sock`, si no, `~/.config/sonar/daemon.sock`; `\\.\pipe\sonar` en Windows |
| Base de datos | `~/.config/sonar/sonar.db` (`SONAR_DB` lo anula) |
| Registro del daemon | `~/.config/sonar/daemon.log`, rotado a 5 MiB, se conservan tres |
| Registros de ejecución | `~/.config/sonar/logs/<grupo>/<servicio>.log` |
| Configuración | `~/.config/sonar/config.yaml` |

`SONAR_SOCKET` anula la ruta del socket en todas partes, tanto para el daemon como para
sus clientes — útil para una segunda instancia aislada. El socket se crea
con permisos 0600 en un directorio 0700, por lo que solo tú puedes comunicarte con él. Solo se ejecuta un daemon a la
vez; un socket dejado por un fallo se limpia en el siguiente inicio.

El daemon se detiene por sí solo después de 30 minutos sin clientes y sin
suscriptores. Establece `daemon.idle_timeout` en el archivo de configuración para cambiarlo, o
`0` para mantenerlo en ejecución.

Los puertos se escanean cada 2 segundos mientras algo está cambiando; cuando no hay nada,
el escáner se ralentiza a 5 segundos con un suscriptor conectado y a 10
segundos sin uno. `daemon.scan_interval` mueve esa base — mínimo 1 s — y
ambos límites superiores se escalan con ella, por lo que elevarla a `5s` retrocede a 12,5 s y 25 s
en lugar de fijar la curva en los límites antiguos. `daemon.stats_interval` es el
ritmo separado al que la cpu, la memoria y la franja de carga del host se actualizan mientras
algo está suscrito. Ambos se leen cuando el daemon se inicia: edita el archivo,
luego `sonar daemon restart`. `sonar daemon status` imprime los valores en
efecto (`scan base`, `stats tick`) junto al intervalo adaptativo en el que el escáner está
ahora mismo.

Un suscriptor que solicite `include: ["health"]` hace que el daemon sondee **cada
puerto en escucha** a un ritmo más lento, no solo los servicios que declaran una
ruta `health:` — esos se consultan en cada tick y llegan a cada suscriptor
se haya solicitado o no health.

### Configuración

`~/.config/sonar/config.yaml` es opcional; las banderas siempre tienen prioridad.```sh
sonar config path
sonar config init
# check
```
I need the actual content of chunk 81 to translate it. Please provide the Markdown text you want translated.```sh
sonar config edit       # open it in $EDITOR
```
I need the input content to translate. Please provide the chunk of Markdown content you'd like translated from English to Spanish.```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
```
Los valores no válidos se ignoran con una advertencia y sonar continúa con los valores predeterminados.
Los overrides de entorno que no tienen clave de configuración: `SONAR_DB`, `SONAR_SOCKET`,
`SONAR_NO_HINTS=1` para silenciar los avisos de migración a continuación, y
`SONAR_NO_AUTOSTART=1` para evitar que cualquier cliente de sonar inicie un daemon que no
encontró — útil en CI, donde una compilación nunca debería dejar un proceso en segundo plano.

El propio conjunto de pruebas de sonar establece `SONAR_NO_AUTOSTART=1` para cada binario de prueba y,
después de la ejecución, busca un daemon que le haya sobrevivido. Esa compuerta solo reclama un
`serve` iniciado desde la raíz temporal privada de la ejecución, por lo que dos suites que se ejecutan en paralelo
en una misma máquina no interfieren con los daemons de la otra;
`SONAR_TESTENV_GATE_ALL=1` la amplía de nuevo a cada `sonar serve` en cualquier lugar bajo
el directorio temporal, que es lo que quiere un runner de CI que posee toda la máquina.

### Agentes: MCP, skills y 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
```
Aquí tienes la traducción al español del contenido:

---

**Nota:** El texto de entrada está vacío. No hay contenido que traducir.```sh
sonar install mcp --generic --print
sonar install skills --print
sonar install hooks --print
# check
```
`install mcp` registra `{"command": "sonar", "args": ["mcp"]}` y deja todos los
demás servidores y claves del archivo intactos; ejecutarlo dos veces no cambia nada, y
`--uninstall` elimina exactamente lo que sonar escribió.

`sonar mcp` es ese servidor: un servidor MCP stdio integrado en el binario que le da
a un agente la vista del daemon sobre la máquina. Lee con `list_ports` e
`inspect_port`, espera con `wait_for_port`, elige y reserva puertos con
`next_free_port` y `claim_port`, y responde al resto de las preguntas de un agente
con `tail_logs`, `health_check`, `dependency_graph`, `port_history` y
`list_sessions`; las acciones y los recursos vienen después. Inicia un daemon si no hay
ninguno en ejecución y se reconecta por sí solo si uno desaparece; sus registros van a stderr,
porque stdout transporta el protocolo.

`install skills` escribe la habilidad incluida, que enseña a un agente a iniciar
servidores con `sonar start --`, a usar `sonar wait` en lugar de dormir, y a
limpiar lo que inició. `install hooks` añade dos hooks de Claude Code: uno
exporta `SONAR_SESSION` para que todo lo que inicia una sesión se le atribuya a ella, el
otro sugiere `sonar start --` cuando un servidor de desarrollo simple está a punto de ejecutarse (aconseja, nunca bloquea). Ambos aceptan `--scope project|user`, `--print` y
`--uninstall`.

### `sonar doctor`

Un comando que verifica todo de lo que sonar depende y dice qué hacer con
lo que esté mal. Es lo que ejecuta la aplicación de escritorio durante la incorporación, y lo que
debes ejecutar tú mismo cuando algo no esté bien.```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
```
I need the input content to translate. Please provide the chunk of Markdown content you'd like me to translate from English to Spanish.```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
```
Cada comprobación reporta `ok`, `warn`, `fail` o `skip`. `skip` significa que no
había nada que revisar — Cursor no está instalado, la máquina no tiene docker, el
socket es una tubería con nombre en Windows — y nunca cuenta en tu contra. El código
de salida es 0 a menos que algo **falle**, así que `sonar doctor` encaja en un
script de configuración.

| check | qué significa |
| --- | --- |
| `cli_on_path` | el binario que ejecutaste es el que PATH resuelve; nombra la instalación que lo oculta si no |
| `cli_version_current` | comparado con la última versión, o `skip` cuando GitHub no es accesible en 2s |
| `config_parses` | tu `config.yaml` carga; un error de sintaxis se reporta con línea, columna y un cursor |
| `config_dir_writable` | el daemon puede escribir su log, bloqueo y base de datos |
| `daemon_reachable` | algo está escuchando en el socket |
| `daemon_version_matches` | el daemon en ejecución es la versión del CLI que estás usando |
| `daemon_protocol` | el protocolo mayor del daemon coincide con el de esta compilación |
| `socket_permissions` | el socket es tuyo y 0600, en un directorio 0700 (`skip` en Windows) |
| `db_ok` | la base de datos abre, está en el esquema más reciente, y su tamaño |
| `mcp_registered.{claude_code,cursor,codex}` | el servidor MCP de sonar está en la configuración de ese cliente |
| `skills_installed` | la skill incluida está instalada y actualizada |
| `hooks_installed` | los hooks opcionales de Claude Code están instalados |
| `project_config` | este proyecto tiene un `.sonar.yaml` que carga |
| `docker` | el CLI de docker está presente y su daemon responde |
| `desktop_installed` | la app de escritorio está instalada, y qué versión (`skip` en Windows) |
| `tray` | el binario obsoleto de macOS `sonar-tray` sigue presente |

`--fix` aplica solo las reparaciones que son seguras de hacer sin supervisión, y
pregunta primero a menos que pases `--yes`: mueve un `config.yaml` que no se puede
analizar a `config.yaml.broken-<timestamp>` y escribe una plantilla nueva (nada se
elimina jamás), reinicia un daemon que no está en ejecución, y ejecuta el
comando `sonar install mcp|skills|hooks` que la comprobación nombra — desde el
directorio de trabajo, tal como lo escribirías, así que ejecuta `--fix` dentro del
proyecto que estás reparando en lugar de apuntar `--project` hacia él. Luego
vuelve a comprobar. Cualquier cosa que no tocará — un binario que oculta otro en
PATH, una skill que sonar no escribió — queda en tus manos con el comando exacto
en la columna `fix`.

La app de escritorio llama a las mismas comprobaciones a través del método
`daemon.doctor` del daemon en lugar de invocar procesos externos. El daemon ejecuta
todo lo que puede desde su propio proceso; las tres comprobaciones que se refieren
al binario del CLI que invocaste (`cli_on_path`, `cli_version_current`,
`daemon_version_matches`) vuelven como `skip` con un detalle que lo indica.

### La app de escritorio

La app de Sonar es la misma vista en una ventana y en la barra de menú o la bandeja
del sistema: grupos a un lado, puertos en una cuadrícula con estadísticas en vivo y
salud, logs, y los botones para todo lo anterior. Habla con el mismo daemon, así
que el CLI y la app nunca discrepan. `sonar install desktop` la instala y `sonar
tray` la lanza.

Hasta que la app se publique, los tarballs de lanzamiento de macOS aún incluyen el
antiguo binario de barra de menú `sonar-tray`, y `sonar tray` recurre a él cuando
la app no está instalada.

### `sonar install desktop`

La app está en beta y aún no está firmada por Apple, así que el CLI la instala:```sh
brew install raskrebs/sonar/sonar && sonar install desktop
```
Ese es todo el montaje del tester. Sonar obtiene un manifiesto de compilaciones publicadas,
elige la que corresponde a tu máquina, verifica su sha256 y su tamaño, la instala
y la abre.

**Por eso la CLI es la que hace la descarga.** macOS adjunta un atributo de cuarentena
a cualquier cosa que un *navegador* guarde, y Gatekeeper se niega a abrir una
aplicación en cuarentena que Apple no haya notarizado. Un archivo que descarga esta CLI
nunca recibe el atributo en primer lugar, así que la beta se abre sin aviso y sin
el baile de clic derecho-Abrir. Sonar ni establece ni elimina atributos de cuarentena —
no hay nada que eliminar.```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
```
El comando no necesita red para decirte qué hace:```sh
sonar install desktop --help | grep -- '--no-launch'
# check
```
Dónde se instala:

| | |
| --- | --- |
| macOS | `/Applications/Sonar.app`, o `~/Applications/Sonar.app` cuando la primera no es escribible (sonar nunca usa `sudo`) |
| Linux | `~/.local/opt/sonar-desktop/Sonar.AppImage`, además de una entrada de menú en `~/.local/share/applications` y un enlace `sonar-desktop` en `~/.local/bin` |
| Windows | aún no — el comando lo indica y sale con código 1 |

`--dir` anula el directorio en ambos casos. En Linux, `--deb` instala el `.deb`
mediante `apt`/`dpkg` en lugar del AppImage, cuando la versión publica uno.

La instalación es atómica: la nueva aplicación se descomprime junto a la anterior y se
intercambia con un renombrado, de modo que una descarga fallida nunca te deja sin una aplicación funcional.
Si la aplicación está abierta, sonar se niega en lugar de reemplazar un paquete en ejecución;
`--force` le pide que se cierre y espera hasta diez segundos.

`sonar install desktop` registra `desktop.installed_version` y
`desktop.installed_path` en `~/.config/sonar/config.yaml`, que es como `sonar
tray` encuentra una aplicación instalada con `--dir` y como la comprobación
`desktop_installed` de `sonar doctor` conoce la versión. De dónde provienen las compilaciones es
`desktop.download_base`, anulado por `SONAR_DESKTOP_BASE` y luego por
`--base` — apúntalos a tu propia compilación para probar una.

### `sonar relay`

El relay es el lado servidor de sonar: un pequeño servicio HTTP, ejecutado por nosotros para
la aplicación alojada y publicado como `ghcr.io/raskrebs/sonar-relay` para que puedas ejecutar
el tuyo propio. No tiene nada que ver con el daemon local — `sonar serve` vigila
tus puertos, `sonar relay serve` responde HTTP para una flota — y se incluye en el
mismo binario solo para que haya un único artefacto que desplegar.

Hoy recopila telemetría anónima de producto: un lote de eventos nombrados por
instalación, sin rutas, sin nombres de host, sin URLs, rechazados en la puerta si un valor incluso
parece uno. Es el mismo servicio que más adelante terminará los túneles
expuestos y gestionará el inicio de sesión.```sh
sonar relay serve --db ./relay.db --project-keys "$(openssl rand -hex 24)"
```
`docs/RELAY.md` contiene las rutas, las reglas de validación exactas, el esquema de almacenamiento
y un despliegue con un solo comando detrás de Caddy en cualquier máquina con Docker.

## Migración desde los comandos antiguos

Los comandos previos a los grupos siguen funcionando e imprimen una sola línea en stderr indicando qué
los reemplazó. Desaparecerán dentro de una versión menor a partir de ahora. `SONAR_NO_HINTS=1`
silencia los avisos, y la salida `--json` nunca los incluye.

| Antiguo | Nuevo |
|---|---|
| `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` (comprobaba un perfil) | `sonar up X` ahora *inicia* el grupo |
| `sonar tray` (app de barra de menús de Swift) | `sonar tray` lanza la app de escritorio |

Los perfiles eran una instantánea de puertos por máquina; `.sonar.yaml` se confirma con
el proyecto. Convierte uno y léelo antes de conservarlo — nada se escribe
por ti:```sh
sonar profile list
# check
```
The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to test the tool without having to verify the signature.```sh
sonar profile export my-app > .sonar.yaml
```
Un perfil nunca registró cómo se inicia un servicio, por lo que la propuesta incluye puertos, nombres y rutas de salud, y tú completas `cmd`.

## Solución de problemas

**Algo anda mal con el daemon.** Ejecuta `sonar daemon log -f` mientras reproduces el problema, y `sonar daemon status` para ver el pid, el tiempo de actividad y el recuento de escaneos. Detenlo con `sonar daemon stop`; todos los comandos de lectura siguen funcionando sin él.

**"daemon unavailable, using direct scan".** Nada está escuchando en el socket. Eso es normal: las lecturas no inician un daemon. Ejecuta `sonar serve -d` si quieres uno.

**Un socket que quedó tras un fallo.** `sonar daemon path` lo muestra; al iniciar un daemon se elimina uno obsoleto por sí solo. Si un segundo daemon se niega a iniciarse mientras el primero ya no está, `sonar daemon restart` limpia el bloqueo.

**Faltan puertos en la lista.** Los procesos propiedad de otro usuario son invisibles sin privilegios; sonar lo indica debajo de la tabla. Vuelve a ejecutar con `sudo sonar list` para verlos. En Linux, debe estar instalado `ss` (`iproute2`); en Windows, se usa `netstat`.

**Un kill no hizo nada.** Los contenedores de Docker se detienen a través del daemon de Docker: revisa `docker ps`. Un proceso que ignora SIGTERM necesita `-f`, y uno supervisado por otra cosa (systemd, Compose `restart: always`) vuelve por diseño: detén al supervisor.

**Nada funciona y no sabes por qué.** `sonar doctor` revisa el binario, la configuración, el daemon, la base de datos y cada integración de una sola vez, e imprime el comando que corrige cada cosa que encuentra.

**Reportar un error.** Incluye estos datos, además de las últimas líneas de `sonar daemon log`:```sh
sonar version
sonar daemon status
sonar doctor --json
# check
```
## Plataformas compatibles

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

La agrupación necesita el directorio de trabajo de cada proceso, y ahora cada
plataforma tiene uno: `/proc` en Linux, `lsof` en macOS, y en Windows una
lectura del PEB del propio proceso. Así que los grupos de git-root,
`project_root` y los nombres basados en cwd funcionan igual en todas partes,
y `sonar init` puede proponer un `.sonar.yaml` a partir de lo que está
escuchando en cualquiera de las tres.

La aplicación de escritorio es más limitada por ahora: `sonar install desktop`
la instala en macOS (Apple Silicon e Intel) y Linux (x86_64 y aarch64). En
Windows el comando indica que la aplicación aún no está disponible y sale con
código 1.

La única limitación es un `sonar.exe` de 32 bits en Windows de 64 bits: no
puede leer la memoria de un proceso de 64 bits, por lo que esos puertos
vuelven sin directorio de trabajo y quedan fuera de su grupo de git-root. Usa
la compilación de 64 bits — lee procesos de 64 y 32 bits por igual. En otros
casos, un puerto cuyo proceso deniega el acceso (un servicio que se ejecuta
como otro usuario, un proceso protegido del sistema) simplemente se deja sin
directorio de trabajo; el resto del escaneo no se ve afectado.

## Contribuyentes

¡Gracias a todos los que han contribuido a sonar!

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