使用说明

🚀 coolify-manager-rs

Gestor completo de despliegues en Coolify — CLI, servidor MCP para VS Code y GUI de escritorio, todo en un único binario Rust.

Administra sitios WordPress con tema Glory, servicios Docker Compose, backups automáticos, health checks, migraciones entre VPS, failover, auditorías de seguridad y mucho más. Reemplaza el coolify-manager PowerShell original con mayor velocidad, seguridad y funcionalidades.

📋 Contenido

Características
Requisitos y build
Configuración
Referencia de comandos CLI
- Dónde compila: buildMode
Modo MCP (VS Code)
GUI de escritorio
Configuración avanzada
Arquitectura
Tests
Compatibilidad

✨ Características

Área	Capacidades
🚢 Deploy	WordPress + Glory theme, servicios Rust/Docker Compose, zero-downtime, rollback automático
🔒 Seguridad	Pre-deploy safety check, backup automático previo, fix-db-auth, wp-security
💾 Backups	SSH remoto (VPS secundario), Google Drive legacy, tiers daily/weekly/manual, restore validado
🏥 Health	HTTP check, patrones fatales, alertas SMTP, `--all` en un solo comando, autorepair
🔍 Investigación	Diagnóstico unificado de incidentes, inspección de contenedores, eventos, stats, logs con patrones, toggle de env vars, métricas PostgreSQL
🗄️ Base de datos	Import/export SQL, diagnóstico de migraciones (`db-check`), aplicar pendientes (`db-migrate`), SQL arbitrario (`run-sql`), restauración de clientes (`restore-client`)
🔄 Migración	Migración completa entre targets, dry-run con preflight real, conmutación DNS automática
🚨 Failover	Restaura un sitio en VPS alternativo sin necesitar el VPS origen
📊 Auditoría	Rendimiento VPS, control-plane de Coolify, Redis/THP, seguridad WordPress y del host
🧱 Host Ops	Hardening SSH, UFW + fail2ban, mantenimiento programado, Tailscale, bootstrap de runtime ligero, instalación/desinstalación de Coolify, purga Docker
🔌 MCP	26+ herramientas para GitHub Copilot / VS Code (JSON-RPC 2.0 sobre stdio)
🖥️ GUI	React 19 + Tauri v2 opcional, también usable como app web con API local
🎮 Extras	Servidores Minecraft, WebSocket Bun, sincronización de variables de entorno

⚙️ Requisitos y build

Requisitos

Rust 1.70+ (probado con 1.94) — instalar rustup
Cargo (incluido con rustup)
Acceso SSH al VPS y token de la API de Coolify
Solo para buildMode=builder: Docker local, git y una VPS de build (buildHost en settings.json) con acceso SSH por clave; ver taller remoto

Build

cargo build --release

El binario se genera en target/release/coolify-manager.exe (~10 MB, sin dependencias externas).

GUI de desarrollo

# Modo Tauri nativo
npm run dev

# Modo web (API local + Vite, sin Tauri)
npm run dev:web

dev:web arranca cargo run -- gui-api --bind 127.0.0.1:8787 y Vite en paralelo. Modo demo forzado: VITE_COOLIFY_MANAGER_DEMO=1.

🔧 Configuración

Variables de entorno

El binario carga .env y .env.local automáticamente desde la raíz del proyecto, antes de leer config/settings.json. Las variables se expanden en el JSON con la sintaxis ${VAR}.

Usa .env.example como plantilla. El archivo real .env está en .gitignore.

Para ver qué ruta de configuración está usando el binario:

coolify-manager get-config-path

La ruta se resuelve en este orden: --config → COOLIFY_MANAGER_CONFIG → ancestros del CWD → CARGO_MANIFEST_DIR → ancestros del ejecutable.

`config/settings.json` — estructura mínima

{
    "vps": {
        "ip": "123.456.789.0",
        "user": "root",
        "sshKey": "C:/Users/user/.ssh/id_ed25519"
    },
    "coolify": {
        "baseUrl": "http://123.456.789.0:8000",
        "apiToken": "tu-token-coolify",
        "serverUuid": "srv-uuid",
        "projectUuid": "proj-uuid",
        "environmentName": "production"
    },
    "wordpress": {
        "dbUser": "manager",
        "dbPassword": "${DB_PASSWORD}",
        "defaultAdminEmail": "admin@example.com"
    },
    "glory": {
        "templateRepo": "https://github.com/user/template.git",
        "libraryRepo": "https://github.com/user/library.git",
        "defaultBranch": "main"
    },
    "sitios": []
}

Targets con políticas host-level

Además del target principal, settings.json puede declarar targets secundarios con políticas de mantenimiento, seguridad y baseline del host. Es la base para optimize-host, maintain-host, check-maintenance-window, harden-ssh, enforce-host-security y schedule-maintenance.

{
    "targets": [
        {
            "name": "standby-vps2",
            "vps": {
                "ip": "173.249.50.44",
                "user": "root",
                "sshKey": "C:/Users/user/.ssh/vps2_backup.pem"
            },
            "coolify": {
                "baseUrl": "http://173.249.50.44:8000",
                "apiToken": "${VPS2_COOLIFY_TOKEN}",
                "serverUuid": "srv-destino",
                "projectUuid": "proj-destino",
                "environmentName": "production"
            },
            "maintenancePolicy": {
                "enabled": true,
                "timezone": "Europe/Madrid",
                "windowStartLocal": "03:00:00",
                "randomizedDelay": "15m",
                "durationBudget": "45m",
                "rebootPolicy": "if-required",
                "maxRebootFrequency": "weekly"
            },
            "securityPolicy": {
                "ssh": {
                    "allowRootKeyOnly": true,
                    "disablePasswordAuth": true,
                    "trustedSourceIps": ["186.14.169.211"]
                },
                "firewall": {
                    "enabled": true,
                    "allowedTcpPorts": [22, 80, 443]
                }
            },
            "hostProfile": {
                "swapGb": 4,
                "swappiness": 10,
                "vfsCachePressure": 50,
                "overcommitMemory": 1,
                "disableThp": true,
                "dockerLiveRestore": true
            }
        }
    ]
}

📖 Referencia de comandos CLI

coolify-manager [OPCIONES GLOBALES] <SUBCOMANDO> [OPCIONES]

Opciones globales

Opción	Descripción
`--log-level <NIVEL>`	Nivel de logging: `trace`, `debug`, `info`, `warn`, `error` (por defecto: `info`)
`--log-dir <DIR>`	Directorio para archivos de log
`-c, --config <RUTA>`	Ruta al `settings.json`
`--mcp`	Inicia en modo MCP (servidor stdio JSON-RPC 2.0)
`--help`	Muestra ayuda
`--version`	Muestra versión

🏗️ Creación y despliegue

`new` — Crear sitio WordPress

coolify-manager new --name mi-sitio --domain https://mi-sitio.com
coolify-manager new --name mi-sitio --domain https://mi-sitio.com --template wordpress --target produccion-b

Opción	Descripción
`-n, --name`	Nombre único del sitio (slug)
`-d, --domain`	Dominio completo con protocolo (`https://...`)
`--template`	Template de stack: `wordpress`, `kamples`, `minecraft` (por defecto: `wordpress`)
`--target`	Target donde desplegar (definido en `settings.json`)
`--skip-theme`	Omite instalación del tema Glory
`--skip-cache`	Omite configuración de cache headers
`--image`	Referencia precargada (`cm-local/<sitio>:<sha12>`, nunca `latest`), cargada en el VPS con `build-laptop` (ver `buildMode` abajo); el VPS no construye

`deploy` — Desplegar / actualizar tema Glory

coolify-manager deploy --name mi-sitio
coolify-manager deploy --name mi-sitio --update --skip-backup
coolify-manager deploy --name mi-sitio --force --glory-branch feature/nueva-ui

Opción	Descripción
`-n, --name`	Nombre del sitio
`--update`	Actualiza en vez de reinstalar
`--glory-branch`	Rama del tema Glory
`--library-branch`	Rama de la librería Glory
`--skip-react`	Omite compilación de React
`--force`	Fuerza `git reset --hard` antes del pull
`--skip-backup`	Omite backup automático pre-deploy

⚠️ Cada deploy ejecuta un pre-deploy safety check (verifica todos los sitios en Coolify) y crea un backup automático antes de aplicar cambios. Usa --skip-backup para omitirlo en cambios de bajo riesgo.

`deploy-service` — Deploy zero-downtime para servicios Docker Compose

Para servicios Rust u otros contenedores personalizados. Construye imagen nueva y hace swap sin downtime.

coolify-manager deploy-service --name mi-servicio
coolify-manager deploy-service --name mi-servicio --skip-build --seed

Opción	Descripción
`-n, --name`	Nombre del sitio en `settings.json`
`--skip-build`	Omite build (asume imagen ya construida)
`--seed`	Ejecuta seed de datos de prueba post-deploy
`--skip-compose-sync`	No sincroniza el compose con la API de Coolify
`--skip-backup`	Omite backup pre-deploy
`--image`	Usa imagen precargada en el VPS (vía `build-laptop`) en vez de construir allí; tag `cm-local/*` o registry con sha, nunca `latest`

Dónde compila `deploy-service` y `redeploy`: `buildMode`

Cada sitio tiene un buildMode que decide el lugar del build. Se cambia con:

coolify-manager set-build-mode --name mi-rust --mode builder

Modo	Dónde compila	Requisitos
`vps`	El VPS 66 (ruta clásica)	Ninguno
`laptop`	La laptop; la imagen se carga en el VPS con `build-laptop`	Docker local
`builder`	La VPS de build (`buildHost`, la 89) con contexto local: el laptop envía `app.bundle` y `framework.bundle`; la 89 no accede a GitHub	Solo Rust; `buildHost` en `settings.json`; `repoLocal` en el sitio

builder falla cerrado: si el commit de la app no casa con el sha del tag o el árbol del framework no casa con FRAMEWORK_TREE, no se construye.
Nota: el texto de ayuda de set-build-mode --mode lista solo laptop | vps; el código acepta además builder (src/domain/mod.rs). Pendiente de corregir el texto.
Retención en la VPS 89 (cm-sweep, cada 15 min desde el 2026-10-19; última línea de /var/log/cm-sweep.log = estado; techos 20 + 10 + 13 + 20 + 15 = 78 GB sobre un disco de 96). El nivel (0 mantenimiento ≥ 25 GB libres, 1 aviso, 2 suelo < 15 GB) solo cambia los umbrales de antigüedad. Un build en marcha ya no salta la corrida: solo se omite lo que necesita el lock de cm-heavy (targets e incremental); docker, /tmp, /var/tmp ajeno y cachés de casa se limpian igual.

Qué	Política
Targets `/var/tmp/glory-target/*`	Purga a las 48 h sin uso (24 h en nivel 1, nada en el suelo); techo 20 GB; bajo el lock de `cm-heavy`
Caché de buildx	`--max-used-space 10GB` sin `--filter`: el filtro de antigüedad solo elegía candidatos y BuildKit podía rendirse antes del techo devolviendo 0 (el log mentía). La antigüedad la gobierna la política de GC de dockerd (`keepDuration`, 7 días); el techo, además, `/etc/docker/daemon.json` (`maxUsedSpace 10GB`)
Imágenes `cm-local/*`	Conserva 2 por sitio; `image prune -f` de dangling
`.tgz` en `/var/tmp`	Más de 1 día; basta un `.tar`/`.gz`/`.xz`/`*.zst` dentro para que el directorio entero no se toque
Suelo	Con menos de 15 GB libres, poda agresiva; `cm-heavy` sale con 75 si `/` tiene menos de `CM_HEAVY_MIN_DISK_GB`

Nada en uso se borra: cada corrida levanta un mapa de cwd, ejecutables y ficheros abiertos de todos los procesos (/proc) y todo borrado pasa por él. El mapa se refresca durante la corrida (cada 5 s antes de un borrado sin umbrales, y entero antes de la segunda pasada y de la poda agresiva), así que lo que arranca con la corrida ya en marcha también queda protegido. Si el mapa sale vacío, no se borra nada.
Taller, medidas y recuperación: taller-remoto-vps89-2026-10-14.md. Reglas de bases de datos: bases-de-datos-taller-2026-10-14.md.

`build-laptop` — Alternativa: compilar en la laptop y cargar en el VPS

coolify-manager build-laptop --name mi-rust
coolify-manager build-laptop --dockerfile config/templates/Dockerfile.kamples --tag cm-local/kamples:abc123def456

Opción	Descripción
`-n, --name`	Nombre del sitio en `settings.json` (modo sitio: template rust; tag default `cm-local/<sitio>:<sha12>` del branch)
`--dockerfile`	Dockerfile suelto a compilar (modo fichero, requiere `--tag`)
`--tag`	Tag fijo (obligatorio en modo fichero)
`--target`	Target de subida/carga en modo fichero (por defecto el default)
`--keep-tarball`	Conserva el `.tgz` local tras la subida
`--docker-bin`	Binario docker local (por defecto `docker`)
`--sin-envio`	Solo `buildMode=builder`: compila en la VPS de build y deja el `.tgz` local sin cargarlo en el target (ensayo de medición)

Flujo: build --pull --no-cache en Docker Desktop → save→gzip en C:\tmp\cm-build\<sitio> → subida a /tmp/cm-laptop-*.tgz (exige el doble de espacio libre) → gunzip -c \| docker load → verificación inspect fail-closed. Detalle y matriz de rutas en Agente/documentacion/deploy-imagen-local-2026-09-30.md. Nota: "build local" es ambiguo (en redeploy.rs significa "local al VPS"); usar siempre el nombre del comando.

`redeploy` — Redeploy seguro del servicio

coolify-manager redeploy --name mi-sitio
coolify-manager redeploy --name mi-sitio --skip-backup

En stacks Rust, redeploy usa el mismo flujo protegido que deploy-service (build + swap sin stop/start) y compila según buildMode (en Rust, builder en la VPS 89). En WordPress, dispara el mecanismo de redeploy de Coolify.

`delete-site` — Borrado seguro de un stack desechable

coolify-manager delete-site --name mi-test --confirm mi-test --dry-run
coolify-manager delete-site --name mi-test --confirm mi-test

Opción	Descripción
`-n, --name`	Nombre del sitio en `settings.json` (única forma de identificar el objetivo; jamás uuid crudo)
`--confirm`	Confirmación tipada: debe ser idéntica a `--name`
`--dry-run`	Solo muestra lo que haría sin tocar host ni API

Garantías: docker compose down --volumes acotado al service_dir (uuid validado antes de rm -rf), DELETE API sin prune global ni redes compartidas, verificación post-borrado (stack en 404 + demás sitios intactos) y eliminación de settings.json. El registro DNS no se elimina (residuo documentado).

📋 Operaciones de sitio

`list` — Listar sitios configurados

coolify-manager list
coolify-manager list --detailed

`restart` — Reiniciar servicios

coolify-manager restart --name mi-sitio
coolify-manager restart --all
coolify-manager restart --name mi-sitio --only-db
coolify-manager restart --name mi-sitio --only-wordpress

Opción	Descripción
`-n, --name`	Nombre del sitio
`--all`	Reinicia todos los sitios
`--only-db`	Solo reinicia el contenedor de base de datos
`--only-wordpress`	Solo reinicia el contenedor WordPress

`stop` — Detener servicios de un sitio (sin borrar nada)

coolify-manager stop --name mi-sitio

Detiene los contenedores vía Coolify API; imagen y volúmenes quedan intactos en el VPS. Sin --all a propósito (un sitio por invocación). Rearranque: botón Start en Coolify o deploy-service --name mi-sitio (Rust).

`logs` — Ver logs del contenedor

coolify-manager logs --name mi-sitio
coolify-manager logs --name mi-sitio --lines 100 --target wordpress
coolify-manager logs --name mi-sitio --wp-debug --filter "Fatal error"
coolify-manager logs --name mi-sitio --since 2h --pattern "error|panic|oom"

Opción	Descripción
`-n, --name`	Nombre del sitio
`-l, --lines`	Número de líneas (por defecto: 50)
`--target`	Contenedor objetivo: `wordpress`, `mariadb`, `postgres`
`--wp-debug`	Ver `debug.log` de WordPress en vez de container logs
`--filter`	Filtrar salida por patrón
`--since`	Filtrar logs desde hace X tiempo (ej: `2h`, `30m`, `1d`)
`--until`	Filtrar logs hasta hace X tiempo
`--pattern`	Buscar patrón regex en los logs (alternativa a `--filter`)

`exec` — Ejecutar comando en el contenedor

coolify-manager exec --name mi-sitio --command "wp option get siteurl"
coolify-manager exec --name mi-sitio --php "echo get_option('blogname');"
coolify-manager exec --name mi-sitio --command "psql -U user -c '\\dt'" --target postgres

Opción	Descripción
`-n, --name`	Nombre del sitio
`--command`	Comando bash a ejecutar
`--php`	Código PHP a ejecutar (vía `wp eval`)
`--target`	Contenedor objetivo: `wordpress` (por defecto), `mariadb`, `postgres`

`run-script` — Subir y ejecutar un script local

coolify-manager run-script --name mi-sitio --file ./scripts/fix-perms.sh
coolify-manager run-script --name mi-sitio --file ./fix.php --interpreter php

Opción	Descripción
`-n, --name`	Nombre del sitio
`-f, --file`	Ruta al script local
`-i, --interpreter`	Intérprete: `php`, `bash`, `python3` (auto-detecta por extensión)
`--target`	Contenedor objetivo (por defecto: `wordpress`)
`--args`	Argumentos adicionales para el script

`debug` — Activar / desactivar WP_DEBUG

coolify-manager debug --name mi-sitio --enable
coolify-manager debug --name mi-sitio --disable
coolify-manager debug --name mi-sitio --status

`set-domain` — Cambiar dominio del sitio

coolify-manager set-domain --name mi-sitio --domain https://nuevo-dominio.com

`git-status` — Estado Git del tema remoto

coolify-manager git-status --name mi-sitio

💾 Base de datos

`import` — Importar SQL

coolify-manager import --name mi-sitio --file backup.sql
coolify-manager import --name mi-sitio --file backup.sql --fix-urls

Opción	Descripción
`-n, --name`	Nombre del sitio
`-f, --file`	Ruta local al archivo `.sql`
`--fix-urls`	Corrige URLs al dominio configurado tras importar

`export` — Exportar SQL

coolify-manager export --name mi-sitio
coolify-manager export --name mi-sitio --output ./backups/export.sql

`fix-db-auth` — Corregir mismatch de contraseña BD

Detecta y corrige cuando DATABASE_URL y la contraseña real de PostgreSQL no coinciden. Causa frecuente: colisión del hostname postgres en redes Docker multi-stack.

coolify-manager fix-db-auth --name mi-sitio
coolify-manager fix-db-auth --name mi-sitio --dry-run

`db-check` — Diagnosticar salud de la base de datos

Verifica el estado de la base de datos PostgreSQL: tablas existentes, migraciones aplicadas, columnas faltantes. Útil después de recrear una BD o cuando hay errores 500 en endpoints que consultan tablas específicas.

coolify-manager db-check --name studio
coolify-manager db-check --name studio --expected-tables infrastructure_servers,server_capacity

Opción	Descripción
`-n, --name`	Nombre del sitio
`--expected-tables`	Lista de tablas que deben existir (separadas por coma)

Salida ejemplo:

[db-check] studio — PostgreSQL health diagnostic
  ✅ 42 tables found in public schema
  ✅ 28 migrations applied (latest: 20260526000000)
  ❌ MISSING TABLE: infrastructure_servers (migration 20260522010000)
  ❌ MISSING COLUMN: hosting_plan_configs.cpu_scaling_policy (migration 20260526000000)
  ⚠️  2 issues found — run `db-migrate` to fix

`db-migrate` — Ejecutar migraciones pendientes remotamente

Aplica migraciones de SQLx pendientes en la base de datos de producción. Detecta automáticamente qué migraciones están en disco pero no aplicadas en _sqlx_migrations.

coolify-manager db-migrate --name studio
coolify-manager db-migrate --name studio --dry-run
coolify-manager db-migrate --name studio --version 20260522010000

Opción	Descripción
`-n, --name`	Nombre del sitio
`--dry-run`	Muestra qué migraciones se aplicarían sin ejecutarlas
`--version`	Aplica solo una migración específica por versión

Flujo:

Conecta por SSH al servidor y al contenedor postgres
Lee _sqlx_migrations para saber qué está aplicado
Compara con los archivos .sql locales del directorio de migraciones
Ejecuta las pendientes en orden
Verifica resultado con db-check

`run-sql` — Ejecutar SQL arbitrario en producción

Ejecuta un archivo SQL o un query directamente contra la base de datos del contenedor. Ideal para restauraciones, fixes puntuales o scripts de diagnóstico.

coolify-manager run-sql --name studio --file ./restore_guillermo.sql
coolify-manager run-sql --name studio --query "SELECT COUNT(*) FROM users"
coolify-manager run-sql --name studio --file ./fix.sql --dry-run

Opción	Descripción
`-n, --name`	Nombre del sitio
`-f, --file`	Ruta local al archivo `.sql`
`-q, --query`	Query SQL directo
`--dry-run`	Ejecuta dentro de `BEGIN`/`ROLLBACK` (no aplica cambios)
`--target`	Contenedor postgres objetivo (auto-detecta por defecto)

Flujo: Lee el archivo local → base64 → SSH → docker exec: decode + psql → resultado.

`restore-client` — Restaurar datos de cliente vía API

Ejecuta el endpoint de bootstrap del cliente para restaurar hostings, billing_items y datos asociados. Encapsula todo el flujo de restauración en un solo comando.

coolify-manager restore-client --name studio --email guillermo@nakomi.com
coolify-manager restore-client --name studio --email guillermo@nakomi.com --stripe-sub-id sub_1TdRDgCdHJpmDkrr69Vn4grz
coolify-manager restore-client --name studio --email guillermo@nakomi.com --dry-run

Opción	Descripción
`-n, --name`	Nombre del sitio
`--email`	Email del cliente a restaurar
`--stripe-sub-id`	ID de suscripción Stripe a vincular (opcional)
`--dry-run`	Muestra qué se haría sin ejecutar
`--password`	Contraseña temporal para el usuario (si se crea)

Flujo:

Verifica si el usuario ya tiene datos (evita duplicados)
Ejecuta el endpoint de bootstrap vía curl dentro del contenedor app
Si --stripe-sub-id: ejecuta UPDATE SQL para vincular la suscripción Stripe
Marca billing_items relacionados como paid si corresponde
Reporta resumen de lo creado/actualizado

🔄 Variables de entorno

`sync-env` — Sincronizar .env con Coolify

# Solo mostrar diferencias
coolify-manager sync-env --name mi-sitio --direction diff

# Subir variables locales a Coolify
coolify-manager sync-env --name mi-sitio --direction push

# Bajar variables de Coolify al .env local
coolify-manager sync-env --name mi-sitio --direction pull

# Solo sincronizar claves específicas
coolify-manager sync-env --name mi-sitio --direction push --only APP_KEY,STRIPE_SECRET

# Ver qué haría sin aplicar cambios
coolify-manager sync-env --name mi-sitio --direction push --dry-run

Opción	Descripción
`-n, --name`	Nombre del sitio
`--direction`	`diff` (solo mostrar), `push` (local→Coolify), `pull` (Coolify→local)
`--dry-run`	Muestra diferencias sin aplicar
`--env-file`	Ruta al `.env` local (auto-detecta por defecto)
`--only`	Limita a claves específicas (separadas por coma)

🔍 Investigación de incidentes

Comandos diseñados para diagnosticar y mitigar incidentes en producción de forma segura. Todos operan via SSH de solo lectura (excepto env-toggle) y redactan automáticamente secretos.

`incident investigate` — Diagnóstico unificado de incidentes

Ejecuta un panel completo de diagnóstico: health, inspección del contenedor, eventos recientes, stats de recursos, logs con patrones de incidente y métricas PostgreSQL.

coolify-manager incident investigate --name studio
coolify-manager incident investigate --name studio --since 4h --json

Opción	Descripción
`-n, --name`	Nombre del sitio
`--since`	Ventana de tiempo para eventos y logs (por defecto: `24h`)
`--json`	Salida en formato JSON

Secciones del reporte:

Health check HTTP
Inspección del contenedor (estado, restart_count, OOM, exit_code, límites)
Eventos del ciclo de vida (create, start, die, destroy, oom, kill)
Stats de recursos (CPU, memoria, red, disco, PIDs)
Logs con patrones de incidente (freeze, panic, OOM, constraint, transaction abort)
Métricas PostgreSQL (conexiones, queries largas, locks, deadlocks, tablas)

`incident logs` — Búsqueda de patrones en logs

Busca patrones de incidente específicos en los logs del contenedor.

coolify-manager incident logs --name studio
coolify-manager incident logs --name studio --since 2h --pattern "panic|oom"

Opción	Descripción
`-n, --name`	Nombre del sitio
`--since`	Ventana de tiempo (por defecto: `1h`)
`--pattern`	Patrón regex personalizado

Patrones por defecto buscados:

FREEZE DETECTED — watchdog detectó congelamiento
panic / thread.*panicked — pánico de Rust
OOM / out of memory — memoria agotada
no unique or exclusion constraint — error SQL de índice parcial
current transaction is aborted — transacción abortada
connection pool / pool timeout — pool de conexiones agotado

`container inspect` — Inspección detallada del contenedor

Muestra datos del contenedor extraídos de docker inspect: estado, restart_count, OOM, límites de memoria/CPU, política de reinicio.

coolify-manager container inspect --name studio
coolify-manager container inspect --name studio --json

`container events` — Historial de eventos del contenedor

Lista los eventos de ciclo de vida (create, start, die, destroy, oom, kill) del contenedor app.

coolify-manager container events --name studio
coolify-manager container events --name studio --since 48h
coolify-manager container events --name studio --since 24h --until 1h

Opción	Descripción
`-n, --name`	Nombre del sitio
`--since`	Eventos desde hace X tiempo (por defecto: `24h`)
`--until`	Eventos hasta hace X tiempo

`container stats` — Métricas de recursos del contenedor

Obtiene CPU, memoria, red, disco y PIDs del contenedor en tiempo real.

coolify-manager container stats --name studio
coolify-manager container stats --name studio --json

`db-stats` — Métricas de PostgreSQL

Consulta métricas de salud de PostgreSQL: conexiones por estado, queries activas largas, lock waits, deadlocks y tablas por tamaño.

coolify-manager db-stats --name studio
coolify-manager db-stats --name studio --threshold 10 --json

Opción	Descripción
`-n, --name`	Nombre del sitio
`--threshold`	Segundos mínimos para considerar una query "larga" (por defecto: `5`)
`--json`	Salida en formato JSON

`db-compare` — Comparación precisa de bases de datos (E12)

Compara la base de datos en vivo de un sitio contra un dump (del VPS o local) o contra otro sitio, de forma segura y precisa. Descubre todas las tablas automáticamente (information_schema / SHOW TABLES) — no depende de listas hardcodeadas, por lo que funciona con tablas personalizadas (pgvector, plugins WordPress, tipos custom).

# Contra el último dump del VPS (PostgreSQL o MariaDB)
coolify-manager db-compare --name studio

# Contra un dump concreto (local o ruta VPS)
coolify-manager db-compare --name studio --dump /data/backups/do8k4w8swccwwogoc0os0ck0/daily/2026-08-28_0100.sql.gz

# Contra otro sitio en vivo (mismo motor)
coolify-manager db-compare --name studio --against glory-rest

# Modo ligero: solo conteos + hash (sin contenedor temporal, sin consumir VPS)
coolify-manager db-compare --name agape --no-tmp-container --json

# Limitar a tablas concretas / ignorar columnas volátiles / muestra limitada
coolify-manager db-compare --name studio --tables projects,users --ignore-columns updated_at --limit-diff 20

Opción	Descripción
`-n, --name`	Nombre del sitio
`--dump`	Ruta al dump (local o VPS). Si se omite y no hay `--against`, usa el último dump del VPS
`--against`	Nombre de otro sitio configurado para comparar en vivo (mutuamente excluyente con `--dump`)
`--tables`	Limitar a tablas concretas (separadas por coma). Por defecto: todas
`--ignore-columns`	Columnas volátiles a ignorar en la comparación (p. ej. `updated_at`)
`--limit-diff`	Máx filas de muestra por tabla en el reporte (por defecto: `20`)
`--json`	Salida en formato JSON estructurado
`--no-tmp-container`	Modo ligero: solo conteos + hash, sin contenedor temporal
`--extract-limit`	Máx filas a extraer por tabla (seguridad, por defecto: todas)

Seguridad y limpieza:

Solo lectura sobre la BD en vivo (nunca escribe en ella).

Modo completo: restaura el dump en un contenedor temporal efímero (--rm, red aislada --network none), nunca toca la BD viva.

El contenedor temporal se elimina siempre (éxito o error), y los dumps subidos a /tmp/dbcompare_*.sql también se borran siempre. Verificado en producción: 0 residuos.

Maneja automáticamente: columnas vector (pgvector) y bytea (excluidas de la proyección canónica), tablas sin PK, y columnas volátiles (vía --ignore-columns).

`env-toggle` — Toggle rápido de variables de entorno

Activa o desactiva feature flags de forma rápida para mitigación de incidentes. Usa la API de Coolify para actualizar env vars y reinicia el contenedor.

coolify-manager env-toggle --name studio --key CHAT_ALERT_CAPTURE_ENABLED --value false
coolify-manager env-toggle --name studio --key CHAT_EMAIL_DELIVERY_ENABLED --value false

Opción	Descripción
`-n, --name`	Nombre del sitio
`--key`	Nombre de la variable de entorno
`--value`	Nuevo valor (`true`/`false` para flags)
`--dry-run`	Muestra qué haría sin aplicar

Seguridad: No permite modificar variables sensibles (DATABASE_URL, JWT_SECRET, API_TOKEN, etc.). Para eso usar sync-env.

🏥 Salud y seguridad

`health` — Health checks

coolify-manager health --name mi-sitio
coolify-manager health --all
coolify-manager health --all --alert
coolify-manager health --name mi-sitio --repair

Opción	Descripción
`-n, --name`	Nombre del sitio (requerido sin `--all`)
`--all`	Verifica todos los sitios
`--alert`	Envía email SMTP si algún sitio está caído
`--repair`	Repara fallos recuperables de red en servicios Rust

`wp-security` — Auditoría de seguridad WordPress

# Auditar plugins, permisos, configuraciones inseguras
coolify-manager wp-security --name mi-sitio --audit

# Rotar contraseña del admin (genera una aleatoria si no se especifica)
coolify-manager wp-security --name mi-sitio --user admin
coolify-manager wp-security --name mi-sitio --user admin --password nueva-pass-segura

`cache` — Gestionar cache headers HTTP

coolify-manager cache --name mi-sitio --action enable
coolify-manager cache --name mi-sitio --action disable
coolify-manager cache --name mi-sitio --action status
coolify-manager cache --action enable --all

📧 SMTP

`smtp` — Configurar relay de correo

coolify-manager smtp --name mi-sitio --host smtp-relay.brevo.com --port 587
coolify-manager smtp --all
coolify-manager smtp --name mi-sitio --test --test-email admin@ejemplo.com
coolify-manager smtp --name mi-sitio --status

💾 Backups y restauración

`backup` — Crear o listar backups externos

# Backup manual con etiqueta
coolify-manager backup --name mi-sitio --tier manual --label antes-de-update

# Backup diario (para usar en cron)
coolify-manager backup --name mi-sitio --tier daily

# Listar backups disponibles
coolify-manager backup --name mi-sitio --list

Opción	Descripción
`-n, --name`	Nombre del sitio
`--tier`	Tier: `daily`, `weekly`, `manual` (por defecto: `manual`)
`--label`	Etiqueta descriptiva opcional
`--list`	Lista backups en vez de crear uno nuevo

Los backups se almacenan en el backend configurado: SSH a VPS secundario (sshremote, recomendado) o Google Drive (legacy). Estructura remota: {baseDir}/{sitio}/{tier}/{backup_id}.tar.gz.

`restore` — Restaurar backup

coolify-manager restore --name mi-sitio --backup-id 20260314_120000-antes_de_update
coolify-manager restore --name mi-sitio --backup-id 20260314_120000 --skip-safety-snapshot

Opción	Descripción
`-n, --name`	Nombre del sitio
`--backup-id`	Identificador del backup
`--skip-safety-snapshot`	Omite snapshot de seguridad previo a la restauración

`schedule-backup` — Programar backups automáticos (Windows Task Scheduler)

# Crear tarea programada para un sitio
coolify-manager schedule-backup --name mi-sitio

# Crear tareas para todos los sitios habilitados
coolify-manager schedule-backup

# Eliminar tareas programadas
coolify-manager schedule-backup --name mi-sitio --remove

`auth-drive` — Autorizar Google Drive (backend legacy)

coolify-manager auth-drive

Inicia el flujo OAuth para autorizar el acceso a Google Drive.

🌐 Migración y DNS

`migrate` — Migrar sitio a otro target

# Validar el plan sin ejecutar (preflight real)
coolify-manager migrate --name mi-sitio --target produccion-b --dry-run

# Migración completa con conmutación DNS automática
coolify-manager migrate --name mi-sitio --target standby-vps2 --switch-dns

Opción	Descripción
`-n, --name`	Nombre del sitio
`--target`	Nombre del target en `settings.json`
`--dry-run`	Preflight real: valida origen/destino sin copiar datos
`--switch-dns`	Conmuta DNS al target tras health OK

`switch-dns` — Conmutar DNS manualmente

# Conmutar al DNS de un target configurado
coolify-manager switch-dns --name mi-sitio --target standby-vps2 --dry-run
coolify-manager switch-dns --name mi-sitio --target standby-vps2

# Conmutar a una IP explícita
coolify-manager switch-dns --name mi-sitio --ip 173.249.50.44

`failover` — Restaurar sitio en VPS alternativo

Recupera un sitio completo en otro VPS usando el backup más reciente, sin necesitar que el VPS original esté operativo.

coolify-manager failover --name mi-sitio --target standby-vps2
coolify-manager failover --name mi-sitio --target standby-vps2 --switch-dns
coolify-manager failover --name mi-sitio --target standby-vps2 --backup-id 20260314_120000

Opción	Descripción
`-n, --name`	Nombre del sitio
`--target`	Target destino en `settings.json`
`--backup-id`	ID de backup específico (por defecto: el más reciente)
`--switch-dns`	Conmuta DNS al target tras health OK
`--skip-provision`	Usa el `stackUuid` existente sin provisionar uno nuevo

🔍 Auditoría e infraestructura

`audit` — Auditar VPS

coolify-manager audit
coolify-manager audit --target produccion-b

Verifica rendimiento (CPU, RAM, disco), configuración de seguridad, versiones y servicios del VPS.

`audit-control-plane` — Auditar y remediar el plano de control de Coolify

coolify-manager audit-control-plane --target standby-vps2
coolify-manager audit-control-plane --target standby-vps2 --since 30m --repair

Audita contenedores core, procesos, scheduler, Horizon, failed jobs, Redis, colas y logs recientes. Con --repair aplica una remediación conservadora antes de reauditar.

`audit-security` — Auditar postura de seguridad del host

coolify-manager audit-security --target standby-vps2

Revisa SSH, firewall, fail2ban y exposición básica de puertos del host.

`audit-redis-latency` — Distinguir Redis lento vs host ruidoso

coolify-manager audit-redis-latency --target standby-vps2
coolify-manager audit-redis-latency --target standby-vps2 --slowlog-count 25

Útil para separar latencia propia de Redis de problemas de THP, overcommit o saturación del nodo.

`optimize-host` — Aplicar optimizaciones host-level repetibles

coolify-manager optimize-host --target standby-vps2 --dry-run --samples 5 --interval-seconds 2
coolify-manager optimize-host --target standby-vps2 --disable-thp --docker-live-restore

Gestiona swap, vm.swappiness, vm.vfs_cache_pressure, vm.overcommit_memory, THP, live-restore de Docker y devuelve una foto resumida del host con procesos y contenedores más calientes.

`maintain-host` — Actualizar paquetes y programar reinicio si hace falta

coolify-manager maintain-host --target standby-vps2 --dry-run
coolify-manager maintain-host --target standby-vps2 --reboot

Actualiza paquetes del host remoto y deja evidencia de kernel activo, kernel instalado y necesidad real de reboot.

`check-maintenance-window` — Evaluar política de mantenimiento declarada

coolify-manager check-maintenance-window --target standby-vps2 --dry-run
coolify-manager check-maintenance-window --target standby-vps2 --apply

Decide si corresponde ejecutar mantenimiento según maintenancePolicy y puede disparar el flujo si la ventana actual es válida.

`schedule-maintenance` — Instalar o retirar timer remoto de mantenimiento

coolify-manager schedule-maintenance --target standby-vps2 --dry-run
coolify-manager schedule-maintenance --target standby-vps2
coolify-manager schedule-maintenance --target standby-vps2 --remove

Instala o elimina el timer remoto que ejecuta el mantenimiento según la política del target.

`harden-ssh` — Endurecer SSH con rollback seguro

coolify-manager harden-ssh --target standby-vps2 --dry-run
coolify-manager harden-ssh --target standby-vps2 --apply

Aplica política SSH declarada en el target y valida reconexión antes de considerar exitosa la operación.

`enforce-host-security` — Aplicar UFW + fail2ban según política del target

coolify-manager enforce-host-security --target standby-vps2 --dry-run
coolify-manager enforce-host-security --target standby-vps2 --apply

Sincroniza firewall y fail2ban con securityPolicy, manteniendo validación y rollback de reconexión.

`coolify-control-plane` — Gestionar el control-plane sin tocar sitios alojados

coolify-manager coolify-control-plane --target standby-vps2 --action status
coolify-manager coolify-control-plane --target standby-vps2 --action stop --include-proxy
coolify-manager coolify-control-plane --target standby-vps2 --action start

Controla solo los contenedores core de Coolify del target, sin actuar sobre los stacks alojados.

`install-coolify` — Instalar Coolify en VPS remoto

coolify-manager install-coolify --target standby-vps2

Conecta por SSH al target e instala Coolify automáticamente.

`bootstrap-target-light` — Preparar runtime ligero de hosting en el target

coolify-manager bootstrap-target-light --target standby-vps2 --dry-run
coolify-manager bootstrap-target-light --target standby-vps2

Asegura el baseline del host para el runtime ligero: Docker, Caddy, MariaDB, Redis, UFW, fail2ban, layout en /srv/hosting y baseline de Caddyfile con sites-enabled.

`uninstall-coolify` — Desinstalar Coolify del target

coolify-manager uninstall-coolify --target standby-vps2 --dry-run
coolify-manager uninstall-coolify --target standby-vps2 --purge-data

Remueve contenedores y redes coolify*, y opcionalmente también /data/coolify y volúmenes persistentes.

`purge-docker-host` — Purgar workloads Docker remanentes del target

coolify-manager purge-docker-host --target standby-vps2 --dry-run
coolify-manager purge-docker-host --target standby-vps2 --all-data

Elimina contenedores, y con --all-data también purga volúmenes, redes custom, imágenes no usadas y builder cache. Útil para dejar un host limpio tras retirar Coolify o desmontar entornos de prueba.

`tailscale` — Preparar conectividad privada de host

coolify-manager tailscale --target standby-vps2 --auth-key-env TAILSCALE_AUTH_KEY --hostname vps2
coolify-manager tailscale --target standby-vps2 --auth-key-env TAILSCALE_AUTH_KEY --probe-url http://10.0.0.5/health

Automatiza el alta del host en Tailscale y puede verificar reachability a un endpoint privado al finalizar.

`deploy-websocket` — Agregar servicio WebSocket

Agrega un servicio WebSocket (Bun) a un stack Kamples existente.

coolify-manager deploy-websocket --name mi-sitio-kamples

🎮 Minecraft

# Crear servidor
coolify-manager minecraft --action new --server-name survival --memory 4G --max-players 20

# Ver logs
coolify-manager minecraft --action logs --server-name survival --lines 100

# Reiniciar
coolify-manager minecraft --action restart --server-name survival

# Ejecutar comando de consola
coolify-manager minecraft --action console --server-name survival --console-command "say Hola"

# Estado del servidor
coolify-manager minecraft --action status --server-name survival

# Eliminar servidor
coolify-manager minecraft --action remove --server-name survival

Opción	Descripción
`-a, --action`	`new`, `logs`, `console`, `restart`, `status`, `remove`
`-s, --server-name`	Nombre del servidor
`--memory`	RAM asignada (por defecto: `2G`)
`--max-players`	Máximo de jugadores (por defecto: `20`)
`--version`	Versión de Minecraft (por defecto: `LATEST`)
`--difficulty`	Dificultad: `peaceful`, `easy`, `normal`, `hard`
`--port`	Puerto externo (por defecto: `25565`)

🛠️ Utilidades

`get-config-path` — Ver ruta de settings.json

coolify-manager get-config-path

`gui-api` — Iniciar API HTTP local para la GUI web

coolify-manager gui-api
coolify-manager gui-api --bind 127.0.0.1:8787

🔌 Modo MCP (VS Code)

El servidor MCP expone las capacidades del manager como herramientas para GitHub Copilot y otros clientes compatibles con el protocolo MCP.

Iniciar en modo MCP

coolify-manager --mcp

Si se invoca sin subcomando, el binario entra en modo MCP automáticamente.

Configuración en `.vscode/mcp.json`

{
    "servers": {
        "coolify-manager": {
            "type": "stdio",
            "command": "${workspaceFolder}/.agent/coolify-manager-rs/target/release/coolify-manager.exe",
            "args": ["--mcp"]
        }
    }
}

🧰 Herramientas MCP disponibles

Herramienta	Descripción
`new_site`	Crear sitio WordPress con tema Glory
`deploy_theme`	Desplegar o actualizar tema Glory
`list_sites`	Listar sitios configurados
`restart_site`	Reiniciar servicios del sitio
`import_database`	Importar SQL a la base de datos
`export_database`	Exportar base de datos a SQL
`coolify_backup`	Crear o listar backups externos
`coolify_restore_backup`	Restaurar backup validado
`coolify_health`	Health checks (individual o todos + alerta)
`coolify_migrate`	Migrar sitio completo a otro target
`coolify_audit_vps`	Auditar VPS principal o target
`coolify_wp_security`	Auditar WordPress y rotar contraseña admin
`exec_command`	Ejecutar comando en contenedor
`view_logs`	Ver logs del contenedor
`debug_site`	Activar/desactivar WP_DEBUG
`cache_site`	Gestionar cache headers HTTP
`git_status`	Estado Git del tema remoto
`set_domain`	Cambiar dominio del sitio
`redeploy`	Redeploy seguro (WP vía Coolify API, Rust vía build+swap)
`setup_smtp`	Configurar SMTP relay
`minecraft`	Gestionar servidores Minecraft
`coolify_failover`	Restaurar sitio en VPS alternativo
`coolify_restart`	Reiniciar con `only_db` / `only_wordpress`
`coolify_switch_dns`	Conmutar DNS a otro target o IP
`install_coolify`	Instalar Coolify en target remoto
`deploy_websocket`	Desplegar servicio WebSocket (Bun)
`run_script`	Subir y ejecutar script local en contenedor
`schedule_backup`	Programar backup automático

📦 Recursos MCP

URI	Contenido
`coolify://config`	Configuración actual
`coolify://sites`	Lista de sitios con estado
`coolify://minecraft`	Servidores Minecraft
`coolify://templates`	Templates Docker Compose disponibles

🖥️ GUI de escritorio

Interfaz visual en React 19 + Tauri v2 con:

📊 Dashboard VPS: CPU, RAM, disco en tiempo real
🟢 Tabla de sitios con estado inline (activo, degradado, caído)
⚡ Acciones contextuales: deploy, restart, backup, logs
💾 Backups globales y por sitio
🖊️ Consola de comandos integrada

Modos de uso

Modo	Comando	Descripción
Tauri nativo	`npm run dev`	App de escritorio completa
Web con API local	`npm run dev:web`	Navegador + API HTTP en `localhost:8787`
Producción web	`coolify-manager gui-api` + build estático	Sin Tauri

🔧 Configuración avanzada

Backups remotos (SSH recomendado)

{
    "backupStorage": {
        "localDir": "backups",
        "remote": {
            "type": "sshremote",
            "host": "10.0.0.20",
            "user": "root",
            "sshKey": "C:/Users/user/.ssh/id_ed25519",
            "baseDir": "/backups/coolify-manager"
        }
    }
}

type soporta sshremote (recomendado) y googledrive (legacy). La integridad de cada backup se verifica post-upload comparando tamaños.

Alertas SMTP

{
    "smtp": {
        "host": "smtp-relay.brevo.com",
        "port": 587,
        "user": "alertas@ejemplo.com",
        "password": "${SMTP_PASSWORD}",
        "fromName": "Coolify Manager",
        "secure": "tls"
    }
}

Targets múltiples (migración / failover)

{
    "targets": [
        {
            "name": "standby-vps2",
            "vps": {
                "ip": "10.0.0.20",
                "user": "root",
                "sshKey": "C:/Users/user/.ssh/id_ed25519"
            },
            "coolify": {
                "baseUrl": "http://10.0.0.20:8000",
                "apiToken": "${VPS2_COOLIFY_TOKEN}",
                "serverUuid": "srv-destino",
                "projectUuid": "proj-destino",
                "environmentName": "production"
            }
        }
    ]
}

DNS automático (Contabo)

{
    "dnsProviders": [
        {
            "name": "contabo-vps1",
            "type": "contabo",
            "clientId": "${CONTABO_CLIENT_ID}",
            "clientSecret": "${CONTABO_CLIENT_SECRET}",
            "username": "${CONTABO_USERNAME}",
            "apiPassword": "${CONTABO_API_PASSWORD}"
        }
    ]
}

Configuración por sitio

{
    "sitios": [
        {
            "nombre": "blog",
            "dominio": "https://blog.com",
            "target": "standby-vps2",
            "stackUuid": "abc123",
            "template": "wordpress",
            "dnsConfig": {
                "provider": "contabo-vps1",
                "zone": "blog.com",
                "switchOnMigration": true
            },
            "backupPolicy": {
                "enabled": true,
                "dailyKeep": 2,
                "weeklyKeep": 2,
                "sourcePaths": ["/var/www/html/wp-content"]
            },
            "healthCheck": {
                "httpPath": "/",
                "timeoutSeconds": 20,
                "fatalPatterns": ["Fatal error", "Uncaught Error"]
            }
        }
    ]
}

🏛️ Arquitectura

                      ┌── CLI (clap · subcomandos de deploy, sitio, host y utilidades)
coolify_manager ──▶   ├── MCP (JSON-RPC 2.0 sobre stdio · 26 tools)
   (librería)         └── GUI API (HTTP local · Tauri v2 / navegador)
        │
        ▼
       Commands (handlers por dominio)
        │
        ▼
   Services (lógica de negocio)
   ├── deploy / rollback / theme
   ├── backup / restore / schedule
   ├── health / alert
   ├── migrate / failover / dns
       ├── audit / security / host ops
   └── minecraft / websocket
        │
        ▼
   Infrastructure
   ├── SSH nativo (russh)
   ├── Coolify API (reqwest + rustls)
   ├── Docker Compose
   ├── Templates YAML
   └── Secrets / env

Dual target: lib.rs (librería) + main.rs (binario). La GUI, el MCP y los tests consumen la misma API interna.

Estructura de directorios

src/
  lib.rs               # Punto de entrada de la librería
  main.rs              # Punto de entrada del binario (CLI / MCP / GUI API)
  api/                 # Funciones estructuradas (SiteSummary, HealthResponse…)
    cli/mod.rs           # Parser clap con subcomandos del manager
  commands/            # Handlers individuales por subcomando
  mcp/                 # Servidor MCP (26 tools + resources)
  services/            # Lógica de negocio por dominio
  infra/               # SSH, API Coolify, Docker, templates, secrets
  config/mod.rs        # Carga y caché de settings.json
  domain/mod.rs        # Tipos de dominio (SiteConfig, BackupMeta…)
  error/mod.rs         # Tipos de error por capa
  logging/mod.rs       # Tracing dual (CLI: stdout+archivo / MCP: stderr/archivo)
gui/
  src/                 # React 19 frontend
  src-tauri/           # Comandos Tauri v2 (workspace member Cargo)
templates/             # Templates Docker Compose YAML
config/                # settings.json (no versionado, en .gitignore)
scripts/               # Scripts auxiliares: cargo/, servidor/, wp/ y quality/
  build-windows.mjs    # build cruzado del .exe en la 89 (node scripts/build-windows.mjs)
  dev-web.mjs          # launcher de desarrollo de la GUI web

🧪 Tests

cargo test

150 tests unitarios cubriendo: configuración, validación, templates, rollback, domain types, errores, secrets, carga de entorno, SSH encoding, Google Drive, SSH backup, utilidades del sistema de backup, API, resolución de tiempos relativos, redacción de secretos, patrones de incidente y métricas de contenedores.

🔁 Compatibilidad

✅ Lee el mismo config/settings.json del coolify-manager PowerShell original sin cambios.
✅ Compatible con los stacks Docker Compose existentes en Coolify.
✅ Los templates Docker Compose son idénticos a los del manager original.
✅ Se puede usar en paralelo con el PowerShell mientras se migra.

📄 Licencia

MIT — ver LICENSE

使用说明

🚀 coolify-manager-rs

📋 Contenido

✨ Características

⚙️ Requisitos y build

Requisitos

Build

GUI de desarrollo

🔧 Configuración

Variables de entorno

config/settings.json — estructura mínima

Targets con políticas host-level

📖 Referencia de comandos CLI

Opciones globales

🏗️ Creación y despliegue

new — Crear sitio WordPress

deploy — Desplegar / actualizar tema Glory

deploy-service — Deploy zero-downtime para servicios Docker Compose

Dónde compila deploy-service y redeploy: buildMode

build-laptop — Alternativa: compilar en la laptop y cargar en el VPS

redeploy — Redeploy seguro del servicio

delete-site — Borrado seguro de un stack desechable

📋 Operaciones de sitio

list — Listar sitios configurados

restart — Reiniciar servicios

stop — Detener servicios de un sitio (sin borrar nada)

logs — Ver logs del contenedor

exec — Ejecutar comando en el contenedor

run-script — Subir y ejecutar un script local

debug — Activar / desactivar WP_DEBUG

set-domain — Cambiar dominio del sitio

git-status — Estado Git del tema remoto

💾 Base de datos

import — Importar SQL

export — Exportar SQL

fix-db-auth — Corregir mismatch de contraseña BD

db-check — Diagnosticar salud de la base de datos

db-migrate — Ejecutar migraciones pendientes remotamente

run-sql — Ejecutar SQL arbitrario en producción

restore-client — Restaurar datos de cliente vía API

🔄 Variables de entorno

sync-env — Sincronizar .env con Coolify

🔍 Investigación de incidentes

incident investigate — Diagnóstico unificado de incidentes

incident logs — Búsqueda de patrones en logs

container inspect — Inspección detallada del contenedor

container events — Historial de eventos del contenedor

container stats — Métricas de recursos del contenedor

db-stats — Métricas de PostgreSQL

db-compare — Comparación precisa de bases de datos (E12)

env-toggle — Toggle rápido de variables de entorno