Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
sonar — Herramienta CLI para inspeccionar y gestionar servicios que escuchan en puertos de localhost | Kitploit
Herramientas/GitHubGitHub/raskrebs/sonar
Utilidades de Propósito GeneralMapeo de RedesEscaneo de PuertosScripting y AutomatizaciónRecopilación de InformaciónDevSecOps
GitHubraskrebs/sonar

sonar

Herramienta CLI para inspeccionar y gestionar servicios que escuchan en puertos de localhost

Ver Repositorio
1.1k3367hace 12 díasRevisado por Kitploit
Compartir
<div align="center">

```
██████    ███    ██████    ██    ██████
██           ██      ██  ██  ██      ██
██      ██   ██  ██  ██  ██  ██      ██
  ██  ██   ██  ██  ██  ██  ██  ████
    ██  ██       ██  ██  ██  ██  ██  ██
██████    ███    ██  ██  ██  ██  ██  ██
```
Know what's running on your machine.

</div>

Sonar shows everything listening on localhost and puts it in order: every port
belongs to a **group** — normally the repository it was started from — and
inside that group to a named **service**. Start your dev servers with
`sonar start` and the whole project becomes one thing you can list as a tree,
wait for, tail, and stop with a single command. Docker containers, Compose
projects and processes you started by hand are picked up too, without any
configuration.

```
$ sonar list --tree
my-app  (3 ports, running)                        ~/code/my-app
├─ 5432  db          postgres:17                  http://localhost:5432
├─ 5173  frontend    vite (v5.4)                  http://localhost:5173
└─ 8000  api         uvicorn app:app              http://localhost:8000
ungrouped (1 port)
└─ 3000  next-server (v16.1.6)                    http://localhost:3000
```

## Instalación

### Homebrew (macOS / Linux)

```sh
brew install raskrebs/sonar/sonar
```

Homebrew 6 rechaza las fórmulas de taps de terceros hasta que confíes en el tap una vez
(`Error: Refusing to load formula raskrebs/sonar/sonar from untrusted tap`):

```sh
brew trust raskrebs/sonar
```

### Script de instalación

```sh
curl -sfL https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.sh | bash
```

Descarga el último binario en `~/.local/bin` y lo añade a tu PATH si es necesario. Reinicia tu terminal o ejecuta `source ~/.zshrc`.

En Windows (PowerShell):

```powershell
irm https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.ps1 | iex
```

Ubicación de instalación personalizada:

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

Instalar una versión específica:

```sh
curl -sfL https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.sh | SONAR_VERSION=vX.Y.Z bash
```

```powershell
$env:SONAR_VERSION="vX.Y.Z"; irm https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.ps1 | iex
```

### Uso de Go

```sh
go install github.com/raskrebs/sonar@latest
```

Completados de shell (autocompletado con tabulador de números de puerto):

```sh
sonar completion zsh > "${fpath[1]}/_sonar"   # zsh
sonar completion bash > /etc/bash_completion.d/sonar  # bash
sonar completion fish | source                 # fish
```

## Sesenta segundos

Describe cómo se ejecuta tu proyecto en un `sonar.yaml` en la raíz del repositorio, en
lugar de un `dev.sh`:

```yaml
name: my-app
services:
  - name: db
    cmd: docker compose up db
    port: 5432
  - name: api
    cmd: uv run uvicorn app:app --port ${port}
    port: auto
    depends_on: [db]
  - name: frontend
    cmd: npm run dev -- --port ${port} --strictPort
    port: auto
    depends_on: [api]
    env:
      VITE_API_URL: ${api.url}
```

Luego inícialo:

```sh
sonar start
```

```
  ✓ db        http://localhost:5432   pid 41022  ~/.config/sonar/logs/my-app/db.log
  ✓ api       http://localhost:21408  pid 41040  ~/.config/sonar/logs/my-app/api.log
  ✓ frontend  http://localhost:21409  pid 41077  ~/.config/sonar/logs/my-app/frontend.log

3 started
following the logs; Ctrl+C stops the 3 services started here
api      | INFO:     Uvicorn running on http://127.0.0.1:21408
frontend | VITE v5.4  ready in 312 ms
```

Sonar elige un puerto libre para cada servicio con `port: auto` y le indica a cada servicio dónde están los demás, de modo que un segundo worktree se ejecuta junto al primero sin que un solo puerto entre en conflicto. `sonar start -d` hace lo mismo en segundo plano, y `sonar down` lo detiene y libera los puertos. En otra terminal:

```sh
sonar list --tree
```

```
my-app  (3 ports, running)                        ~/code/my-app
├─ 5432   db          postgres:17                 http://localhost:5432
├─ 21408  api         uvicorn app:app             http://localhost:21408
└─ 21409  frontend    vite (v5.4)                 http://localhost:21409
```

¿No hay `sonar.yaml`? `sonar start -- npm run dev` ejecuta un comando como un servicio con nombre, y `sonar list` y `sonar kill` funcionan con cualquier cosa que esté escuchando.

Los ejemplos a continuación marcados con `# check` se ejecutan contra una compilación nueva mediante
`scripts/readme-check.sh` en cada ejecución de CI.

## Comandos

### `sonar list`

```sh
sonar list
sonar list --tree
sonar list --group my-app
sonar list --json
# check
```

```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
```

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 después 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 casualmente están escuchando — Figma, Discord,
Spotify, ControlCenter, los bundles `.app` de macOS, los daemons de `/System/Library/` — están
ocultos a menos que pases `-a`.

### `sonar start`

Inicia un proyecto desde su `sonar.yaml`:

```sh
sonar start                    # every service in the nearest sonar.yaml
sonar start api frontend       # only these (they still wait for their dependencies)
sonar start ../other-project   # the sonar.yaml in or above another directory
sonar start -d                 # in the background, like `sonar up`
```

En primer plano, sonar inicia los servicios a través del daemon, sigue sus
logs con el nombre del servicio delante de cada línea, y cuando pulsas Ctrl+C
detiene los servicios que inició. Un servicio que ya estaba en ejecución se deja
intacto, y sonar regresa por sí solo una vez que todos los servicios que inició
han finalizado.

Los argumentos antes de `--` nombran un directorio o servicios; todo lo que va después de `--` es un
comando. O ejecuta un comando como un servicio con nombre dentro de 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:

- **Group** — `--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.
- **Name** — `--name`, si no, el servicio de `sonar.yaml` cuyo `cmd` coincida, si no,
  inferido del comando (`npm run dev` → `dev`, `uv run api` → `api`,
  `python -m uvicorn` → `uvicorn`, `./dev.sh` → `dev.sh`).
- **Port** — `--port` es una sugerencia, no un vínculo: la ejecución se muestra como `starting`
  hasta que el puerto esté realmente escuchando, y el daemon lo usa para emparejar 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,
así 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ó,
y debajo lo que ha terminado desde entonces — con el código de salida, y si se bloqueó
o fue detenido (`--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 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 start` inicia el servicio. `cwd` es relativo al
  archivo y no puede salir 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*. Informa `ok`, `fail` o
  `unknown`, con el motivo de un 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 inválido se informa una vez y nunca detiene un escaneo.
- `env` — variables establecidas para el servicio cuando sonar lo inicia.

#### `port: auto` y referencias

Un servicio puede dejar su puerto a sonar, y encontrar los demás a través de su
entorno en lugar de un `localhost:8080` codificado:

```yaml
services:
  - name: api
    cmd: uv run uvicorn app:app --port ${port}
    port: auto
  - name: frontend
    cmd: npm run dev -- --port ${port} --strictPort
    port: auto
    depends_on: [api]
    env:
      VITE_API_URL: ${api.url}
```

`sonar start` reclama un puerto libre para cada servicio `port: auto` que inicia: el
mismo cada vez en el mismo checkout, y uno diferente en cada otro
checkout, de modo que un worktree nunca colisiona con el principal. El servicio lo recibe
como `PORT`, `SONAR_PORT` y `${port}`, y tiene que usarlo — leer `PORT`, o
pasar `${port}` en su línea de comandos. Un servicio que ya está en ejecución conserva
su puerto, así que uno iniciado después todavía lo encuentra. La reclamación detrás de un puerto
asignado dura un día desde el último inicio; `claims.ttl` cambia eso (ver El
daemon).

`${port}` y `${url}` (`http://localhost:<port>`) son del propio servicio;
`${<service>.port}` y `${<service>.url}` son de otro. Funcionan en `cmd`
y en `env`. Una referencia a un servicio que no está en el archivo, o a uno sin
puerto, es un error cuando se carga el archivo. Cualquier otra cosa entre `${` y
`}`, como `${HOME}`, se deja exactamente como está escrita.

`sonar.yml` se lee si así es como lo escribes; `sonar init` siempre escribe
`sonar.yaml`. El archivo solía ser el dotfile `.sonar.yaml`, y ese nombre
todavía funciona: sonar busca `sonar.yaml`, `sonar.yml`, `.sonar.yaml` y
`.sonar.yml`, en ese orden, y lee el primero que encuentra. Las ediciones vuelven
al archivo que sonar leyó, así que nada se renombra a tus espaldas. `sonar doctor`
señala un archivo con el nombre antiguo, y `sonar doctor --fix` lo renombra
(con `git mv` cuando el archivo está rastreado). El daemon vigila los proyectos que conoce y recoge
las ediciones del archivo sin 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, de modo 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 final (`cmd: x     # note`) se colapsan a uno, porque la
biblioteca YAML conserva el comentario pero no su columna.

#### `sonar env`

A qué resuelve el archivo es legible sin iniciar nada:

```sh
sonar env                      # every service: port, url and its expanded env
sonar env frontend             # one service, as export lines
sonar env --json               # for tools
```

```
SERVICE   PORT   URL                     ENV
db        5432   http://localhost:5432
api       21408  http://localhost:21408  DB_URL=postgres://localhost:5432/app
frontend  21409  http://localhost:21409  VITE_API_URL=http://localhost:21408
```

Un servicio `port: auto` que no está en ejecución recibe aquí su reclamación, la misma reclamación que hace `sonar start`, así que lo que `sonar env` imprime es lo que un inicio posterior vincula; un servicio que ya está en ejecución conserva el puerto en el que está. Con nombre, un servicio se muestra como líneas `export`, para que un shell pueda ver lo que el servicio haría:

```sh
eval "$(sonar env frontend)" && npm test
```

Detrás está `groups.env` en el daemon, para un editor o un agente que conecta
un worktree antes de que existan sus servicios.

### `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
```

`sonar up` es `sonar start -d`, que también puede nombrar un grupo desde cualquier lugar y
iniciarlo en otro host. Inicia cada servicio que el `sonar.yaml` del grupo
declara, en orden de `depends_on`:
un servicio espera a los puertos que declaran sus dependencias antes de iniciarse, y
uno que ya está escuchando se omite. Cada uno se ejecuta en segundo plano en su propio grupo de procesos,
con su salida en `~/.config/sonar/logs/<group>/<service>.log`, y con
el entorno del shell en el que ejecutaste `sonar up`, más `PORT` para un servicio
con un puerto.

```
  ✓ db        http://localhost:5432  pid 41022  ~/.config/sonar/logs/my-app/db.log
  - api       already running
  ✓ frontend  http://localhost:5173  pid 41108  ~/.config/sonar/logs/my-app/frontend.log

2 started, 1 already running
```

Un servicio que no arranca se reporta en su propia línea y hace que el comando
salga con un código distinto de cero, sin importar qué más haya ocurrido. Deténlos todos de nuevo con `sonar down`.
`sonar up` necesita el daemon y lo inicia si aún no está en ejecución.

### `sonar down`

```sh
sonar down                     # the project in the nearest sonar.yaml
sonar down my-app              # a group by name
sonar down --only api,worker   # only these services
```

Detiene todos los servicios del proyecto — cada puerto en el que escucha, y cada
servicio que sonar inició para él que no ocupa un puerto, como un worker — y libera
los puertos que sonar reclamó para sus servicios con `port: auto`. `--only` reduce todo
eso a los servicios nombrados, de la misma forma en que `sonar up --only` inicia solo algunos; un nombre
que el archivo no declara es un error. `sonar kill -g my-app` detiene los puertos
y no libera nada.

### `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` lista 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 puede afirmar: los
puertos escuchando dentro del proyecto en este momento (las aplicaciones de escritorio y los puertos por debajo de 1024 quedan excluidos), más lo que un archivo compose o un `package.json` declaran directamente — un
servicio por cada servicio de compose, con su puerto publicado y su `depends_on`, y
el script `dev` ejecutado por el gestor de paquetes al que tu lockfile te compromete.
Donde ambos discrepan, gana el puerto escuchando: es evidencia, no una
afirmación. El archivo que escribe dice lo que no pudo determinar.

Nada más se detecta. Un objetivo de Makefile, una línea de Procfile, un punto de entrada
enterrado en un framework — esas son conjeturas sobre tu repositorio, y una tabla de
ellas nunca estaría terminada. Esa parte va a un agente:

```sh
sonar init --agent              # whichever agent is installed
sonar init --agent codex        # name one
sonar init --agent claude -- --allow-dangerously-skip-permissions
```

`--agent` abre el agente de programación que ya tienes, en esta terminal, con el
prompt ya enviado: lo que sonar sabe, el borrador que habría escrito, el
formato, y la regla de que escribe el archivo y no inicia nada. Lo observas
leer el repositorio y apruebas sus ediciones exactamente como siempre lo haces — es tu
agente, bajo tus permisos — y cualquier cosa después de `--` se le pasa. sonar
conoce `claude`, `codex`, `cursor-agent` y `opencode`; con varios instalados,
nombra uno. Cuando el agente sale, sonar carga el archivo e imprime los servicios que
declara, o por qué no carga. Sin una terminal — una tubería, CI — `--agent`
imprime el prompt en lugar de iniciar nada.

Se niega a sobrescribir sin `--force`, y `--dry-run` imprime el archivo
en lugar de escribirlo. `--merge` añade a un archivo que ya está ahí
en lugar de negarse, y `--service name:port[:health]` — repetible — escribe
los servicios que nombras en lugar de los que encontró, manteniendo el comando que
adivinó para un puerto que conservaste. `--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 en `depends_on`, y `sonar groups remove <group> <name>` elimina uno y
lo quita de cada `depends_on` que lo nombraba. 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 está ahí — y ninguno de ellos escribe un byte hasta que
toda la edición se sabe que es buena.

El daemon hace la escritura, que es por lo que el archivo vuelve con sus comentarios
y orden de claves intactos, ya sea que la edición venga 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` acepta cualquier selector y no cambia nada: imprime las acciones que
realizaría el kill, 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 interpreta como un puerto, y como un pid solo cuando no hay nada escuchando en ese número. `-g` coincide con el grupo resuelto, una etiqueta o id de ejecución heredada, y el proyecto Compose, sin distinguir mayúsculas y minúsculas.

A un proceso que ignora SIGTERM se le envía SIGKILL una vez que el puerto sigue escuchando después de `--grace` (5s); `--no-escalate` desactiva eso. Se señala a los hijos antes que a los padres, por lo que un árbol se derriba en orden. Los contenedores Docker se detienen con `docker stop` y nunca se les envía señal. 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 una asignación 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
```

```sh
sonar history --since 1h
sonar history --json
# check
```

Los nombres y pines 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:<group>/<name>`), el contenedor (`docker:<project>/<service>`), 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.

### Leer 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
```

```sh
sonar next 3000
sonar next 3000-3100 -n 3 --json
sonar graph --json
sonar info --help
# check
```

`sonar wait` sale con `0` (listo), `1` (tiempo de espera agotado) o `2` (interrumpido), lo que lo convierte en lo que hay que 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 pregunta al daemon si hay uno
en ejecución, porque ya tiene la respuesta y no tiene que bifurcar `lsof`.
Si no hay ninguno en ejecución, escanean directamente e imprimen una nota en stderr dicié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 se ha ido. 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
```

```sh
sonar host
# check
```

El daemon mide su propia máquina según la cadencia de escaneo y la publica como la
fila `localhost` de la colección `hosts` de la instantánea: os y kernel, uptime, porcentaje de cpu,
load average, memoria y el disco que contiene `/`. El porcentaje de CPU es el trabajo
realizado entre dos escaneos, por lo que es null hasta que el daemon ha escaneado dos veces; una
cifra que una plataforma no puede producir —el load average en Windows, que no tiene—
es null 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 mantiene la muestra anterior contra la que se mide un porcentaje.

Las GPUs se listan bajo su host con utilización y memoria: desde `ioreg` en
macOS (la memoria de Apple silicon es unificada, por lo que solo se muestra lo que la GPU retiene),
y desde `nvidia-smi` o los contadores sysfs de amdgpu en Linux. El daemon las lee
cada cinco segundos en segundo plano, nunca en la ruta de un comando; `gpus` es null
donde no hay fuente (Windows, Linux solo con Intel) y `[]` en una máquina sin
GPU.

### `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 conectarte por ssh e inicia su daemon allí. El
archivo de la release se descarga y se verifica su checksum **en el host remoto** — no se copia
nada desde esta máquina — y el binario acaba en `~/.local/bin/sonar`, así que
nada de esto necesita root. El daemon se ejecuta como una unidad de usuario de systemd donde el host
tiene una (`~/.config/systemd/user/sonar.service`), y en modo detached donde no
la tiene; `loginctl enable-linger` se imprime como consejo cuando la sesión del usuario terminaría
al cerrar sesión y se llevaría el daemon consigo.

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

El destino se pasa a `ssh` sin tocar: un alias `Host` de `~/.ssh/config` funciona,
y también lo hacen los `ProxyJump`, `IdentityFile` y `Port` que establece. `--identity` y
`--ssh-arg` están ahí para los flags 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 hacia él — `ssh <target> sonar daemon stdio`, buscando en
`~/.local/bin` antes del `PATH` remoto — y multiplexa
lo que reporta en el estado que todos los clientes ya leen. Nada nuevo 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 tienen como clave `<host>/<port>:<bind>`, que
es lo que permite que el puerto 3000 en dos máquinas sean dos filas. Un suscriptor ve solo
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; `--ssh-arg`, `--identity` y `--port` cubren lo que una configuración
no cubre, y `--remote-bin` nombra un sonar que está en otro sitio. El comando
predeterminado se ejecuta a través de `sh`, así que un host Windows, cuyo sonar proviene del
instalador de PowerShell, necesita `--remote-bin sonar`. sonar no almacena ninguna contraseña ni ninguna clave. Un host que se va mantiene su
fila y su estado mientras el daemon reintenta, retrocediendo de un segundo a
treinta durante todo el tiempo que permanezca registrado.

`--host` también sigue aceptando un `user@host` simple que sonar no conoce: recurre
al escaneo sin agente `ssh` + `ss`/`lsof` e imprime una sugerencia para
`sonar remote install`.

#### Actuar sobre otra máquina

Toda 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 envelope que devuelve una llamada local — cada
fila de resultado 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
hace streaming: `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 devolverla directamente
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 dice que se haga ssh y se adjunte 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 el daemon ejecutándose aquí — es donde vive la
conexión a la otra máquina — y lo dice en lugar de escanear silenciosamente
esta máquina en su lugar.

`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, sondea el estado, 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, claim ttl
sonar daemon path            # the socket it listens on
sonar daemon log -n 50 -f    # what it is doing
sonar daemon restart
sonar daemon stop
```

```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 sobrescribe) |
| Log del daemon | `~/.config/sonar/daemon.log`, rotado a 5 MiB, se conservan tres |

---

[Read more](https://github.com/raskrebs/sonar)
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    369
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    282

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →