magicserve 1.2.0

package/README.es.md

@@ -0,0 +1,123 @@
+# Magicserve 🪄
+
+*[Read in English](README.md)*
+
+Magicserve es una herramienta CLI para gestionar entornos de desarrollo web locales. Su objetivo es iniciar, detener y manejar el estado de múltiples servidores locales (`node` y `php`) al mismo tiempo, y automáticamente levantar un Reverse Proxy (Nginx) y generar certificados SSL vía `mkcert` para asignarle un dominio dinámico (ej. `tu-proyecto.test`).
+
+## Requisitos
+
+Antes de utilizar `magicserve`, es necesario tener instalado en la computadora de desarrollo:
+- [Node.js y npm](https://nodejs.org/)
+- [jq](https://jqlang.github.io/jq/) (`brew install jq`)
+- [mkcert](https://github.com/FiloSottile/mkcert) (`brew install mkcert`)
+- Nginx (`brew install nginx`)
+- PHP (si tu proyecto requiere servicios backend en php)
+
+## Instalación global
+
+Si tienes los requisitos instalados, puedes instalar la utilidad de manera global usando npm:
+
+```bash
+npm install -g davidlomas/magicserve
+```
+
+> **Nota:** También puedes publicarlo en npm publico y usar `npm install -g magicserve` directamente.
+
+## Actualización
+
+Si ya tienes `magicserve` instalado y quieres actualizarlo a la última versión, ejecuta el mismo comando de instalación:
+
+```bash
+npm install -g davidlomas/magicserve
+```
+
+Esto sobreescribirá la versión anterior con la más reciente directamente desde GitHub. Tus archivos `magicserve.json` en tus proyectos **no se verán afectados**.
+
+> 💡 Puedes verificar la versión instalada ejecutando cualquier comando de `magicserve`, aparecerá al inicio.
+
+## ¿Cómo se usa?
+
+Una vez instalado de manera global, dirígete a cualquier carpeta en tu computadora que servirá como "nodo central" o "espacio de trabajo" de tus proyectos, y ejecuta:
+
+```bash
+magicserve init
+```
+
+Este comando creará automáticamente un archivo base llamado **`magicserve.json`** en el directorio actual. 
+
+### Archivo de configuración: `magicserve.json`
+
+Tu directorio central gestiona y levanta las aplicaciones referenciadas dentro del **`magicserve.json`**. Su estructura es así de sencilla:
+
+```json
+[
+    {
+        "path": "../tu-proyecto-frontal",
+        "domain": "tu-proyecto.test",
+        "type": "node",
+        "port": 3000
+    },
+    {
+        "path": "../tu-api-backend",
+        "domain": "api.tu-proyecto.test",
+        "type": "php",
+        "port": 3001,
+        "tunnel": "mi-super-api-dev"
+    }
+]
+```
+
+**Propiedades:**
+- **`path`**: Ruta relativa o absoluta hacia el directorio del proyecto donde se deberá correr el servidor.
+- **`domain`**: El dominio de desarrollo local que se enlazará automáticamente (eg. `*.test`).
+- **`type`**: `node` (Correrá usando `npm run dev`) o `php` (Correrá el built-in server usando `php -S`).
+- **`port`**: El puerto interno que el servicio ocupará.
+- **`tunnel`**: *(Opcional)* Subdominio para enlazar puerto interno y exponerlo a internet público a través de `localtunnel` (Ej. webhooks de Mercado Libre o pruebas móviles).
+
+Una vez configurado o modificado a tu gusto, utiliza los comandos de control.
+
+## Comandos disponibles
+
+## Arquitectura: ¿Cómo funciona bajo la manga?
+
+Magicserve orquesta en segundos varias herramientas subyacentes para que tú solo te preocupes por el código de tu proyecto.
+
+```mermaid
+flowchart TD
+    Dev([👨‍💻 Desarrollador])
+    World([🌐 Webhooks Externos])
+    
+    subgraph Tu Computadora Local
+        Nginx(Nginx Proxy Inverso SSL)
+        LT(LocalTunnel Túnel Reverso)
+        Node((Servidor Node\nEj. 3000))
+        PHP((Servidor PHP\nEj. 3001))
+    end
+
+    Dev -- "https://tu-proyecto.test" --> Nginx
+    World -- "https://mi-api.loca.lt" --> LT
+    
+    Nginx -- "localhost:3000" --> Node
+    Nginx -- "localhost:3001" --> PHP
+    LT -- "Túnel" --> PHP
+```
+
+
+Dentro del directorio donde está tu `magicserve.json`, dispones de los siguientes comandos mágicos:
+
+- **`magicserve start`**: Inicia todos los servicios del `magicserve.json` en los puertos definidos, genera certificados SSL dinámicos de ser necesario y configura Nginx.
+- **`magicserve stop`**: Detiene ordenadamente los servicios activos mencionados de tu `magicserve.json`.
+- **`magicserve status`**: Te muestra en terminal cuáles de tus proyectos están activos actualmente y cuál es su PID.
+- **`magicserve stopall`**: Comando de emergencia. Busca y destruye TODOS los demonios, configuraciones temporales nginx relacionadas, certificados, puertos y purga todas las entradas de localhost customizadas en todo el sistema, restaurando tu computadora.
+
+---
+
+### Novedades en v1.2.0 🚇
+
+- **Localtunnel Integrado**: Expón de forma permanente y automática puertos de tu API al internet vía la nueva propiedad `tunnel` en el config json para recibir **Webhooks** de terceros (Mercado Libre, Stripe, etc).
+
+### Novedades en v1.1.0 🚀
+
+- **Visualización de Versión**: Ahora puedes ver la versión de Magicserve directamente en la terminal al ejecutar cualquier comando.
+- **Soporte para Archivos Grandes**: Nginx y PHP se configuran automáticamente para soportar payloads de hasta **100MB** (uploads y JSON), solucionando el error "413 Request Entity Too Large".
+- **SSL Automático**: Soporte nativo para HTTPS vía `mkcert`.

package/README.md

@@ -0,0 +1,122 @@
+# Magicserve 🪄
+
+*[Leer en Español](README.es.md)*
+
+Magicserve is a CLI tool for managing local web development environments. Its goal is to start, stop, and manage the state of multiple local servers (`node` and `php`) simultaneously, automatically set up a Reverse Proxy (Nginx), and generate SSL certificates via `mkcert` to assign them a dynamic local domain (e.g. `your-project.test`).
+
+## Requirements
+
+Before using `magicserve`, you must have the following installed on your development machine:
+- [Node.js and npm](https://nodejs.org/)
+- [jq](https://jqlang.github.io/jq/) (`brew install jq`)
+- [mkcert](https://github.com/FiloSottile/mkcert) (`brew install mkcert`)
+- Nginx (`brew install nginx`)
+- PHP (if your project requires a PHP backend service)
+
+## Global Installation
+
+If you have the requirements installed, you can globally install the utility using npm directly from GitHub:
+
+```bash
+npm install -g davidlomas/magicserve
+```
+
+> **Note:** You can also publish it to the public npm registry and use `npm install -g magicserve`.
+
+## Updating
+
+If you already have `magicserve` installed and want to update to the latest version, simply run the same install command again:
+
+```bash
+npm install -g davidlomas/magicserve
+```
+
+This will overwrite the previous version with the latest one directly from GitHub. Your `magicserve.json` files in your projects **will not be affected**.
+
+> 💡 You can verify the installed version by running any `magicserve` command — it will be displayed at the top.
+
+## How to Use
+
+Once installed globally, navigate to any folder on your computer that will serve as a "central hub" or "workspace" for your projects, and run:
+
+```bash
+magicserve init
+```
+
+This command will automatically create a base **`magicserve.json`** file in the current directory. 
+
+### Configuration File: `magicserve.json`
+
+Your central directory manages and starts the applications referenced within the **`magicserve.json`**. Its structure is this simple:
+
+```json
+[
+    {
+        "path": "../your-frontend-project",
+        "domain": "your-project.test",
+        "type": "node",
+        "port": 3000
+    },
+    {
+        "path": "../your-backend-api",
+        "domain": "api.your-project.test",
+        "type": "php",
+        "port": 3001,
+        "tunnel": "my-cool-api-dev"
+    }
+]
+```
+
+**Properties:**
+- **`path`**: Relative or absolute path to the project's directory where the server should run.
+- **`domain`**: The local development domain that will be automatically mapped (e.g. `*.test`).
+- **`type`**: `node` (Runs using `npm run dev`) or `php` (Runs the PHP built-in server using `php -S`).
+- **`port`**: The internal port the service will use.
+- **`tunnel`**: *(Optional)* Subdomain to securely expose your internal port to the public internet via `localtunnel` (Great for testing third-party Webhooks like Mercado Libre or local mobile testing).
+
+Once configured or modified to your liking, you can use the control commands.
+
+## Available Commands
+
+## Architecture: How it works under the hood
+
+Magicserve instantly orchestrates multiple local tools so you don't have to manage them manually.
+
+```mermaid
+flowchart TD
+    Dev([👨‍💻 Developer])
+    World([🌐 External Webhooks / Web])
+    
+    subgraph Your Local Machine
+        Nginx(Nginx Reverse Proxy with HTTPS)
+        LT(LocalTunnel Reverse Tunnel)
+        Node((Node Server\ne.g. 3000))
+        PHP((PHP Server\ne.g. 3001))
+    end
+
+    Dev -- "https://your-project.test" --> Nginx
+    World -- "https://my-api.loca.lt" --> LT
+    
+    Nginx -- "localhost:3000" --> Node
+    Nginx -- "localhost:3001" --> PHP
+    LT -- "Tunnel" --> PHP
+```
+
+Within the directory where your `magicserve.json` is located, you have the following magic commands available:
+
+- **`magicserve start`**: Starts all services declared in `magicserve.json` on the defined ports, generates dynamic SSL certificates if necessary, and configures Nginx.
+- **`magicserve stop`**: Orderly stops the active services mentioned in your `magicserve.json`.
+- **`magicserve status`**: Shows a terminal output of which projects are currently active and their PIDs.
+- **`magicserve stopall`**: Emergency command. Finds and destroys ALL active daemons, related Nginx configurations, certificates, processes, and purges all custom localhost entries system-wide, restoring your computer's clean state.
+
+---
+
+### Features in v1.2.0 🚇
+
+- **Integrated Localtunnel**: Permanently and automatically expose any of your API ports to the internet via the new `tunnel` property in config JSON to seamlessly receive third-party **Webhooks** (Mercado Libre, Stripe, etc).
+
+### Features in v1.1.0 🚀
+
+- **Version Display**: Now you can see the Magicserve version directly in the terminal.
+- **Large Body Support**: Nginx and PHP are automatically configured to support up to **100MB** payloads (JSON and file uploads), fixing the "413 Request Entity Too Large" error.
+- **Automatic SSL**: Native support for HTTPS via `mkcert`.

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "magicserve",
+  "version": "1.2.0",
+  "description": "Script to run local environments via magicserve.json",
+  "files": [
+    "run.sh"
+  ],
+  "bin": {
+    "magicserve": "./run.sh"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davidlomas/magicserve.git"
+  },
+  "keywords": [
+    "local",
+    "run",
+    "env",
+    "magicompras"
+  ],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/davidlomas/magicserve/issues"
+  },
+  "homepage": "https://github.com/davidlomas/magicserve#readme"
+}

package/run.sh

@@ -0,0 +1,473 @@
+#!/bin/bash
+
+# run.sh
+
+# El directorio de trabajo actual (donde se ejecuta el comando)
+SCRIPT_DIR="$(pwd)"
+CONFIG_FILE="$SCRIPT_DIR/magicserve.json"
+
+# El directorio donde reside el script (para leer package.json)
+REAL_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+VERSION=$(jq -r '.version' "$REAL_SCRIPT_DIR/package.json" 2>/dev/null || echo "1.1.0")
+
+MAGICSERVE_DIR="$SCRIPT_DIR/.magicserve"
+LOGS_DIR="$MAGICSERVE_DIR/logs"
+PIDS_DIR="$MAGICSERVE_DIR/pids"
+
+# Asegurar que los directorios internos existen
+mkdir -p "$LOGS_DIR" "$PIDS_DIR"
+
+echo "🪄 Magicserve v$VERSION"
+echo ""
+
+if [ "$1" != "stopall" ] && [ "$1" != "init" ] && [ ! -f "$CONFIG_FILE" ]; then
+    echo "❌ Error: magicserve.json no encontrado en el directorio actual."
+    echo "💡 Truco: Ejecuta 'magicserve init' para generar un template base."
+    exit 1
+fi
+
+if ! command -v jq &> /dev/null; then
+    echo "❌ jq no instalado → brew install jq"
+    exit 1
+fi
+
+ACTION=$1
+
+usage() {
+    echo "Uso:"
+    echo "  magicserve [start|stop|stopall|status|init]"
+    echo ""
+    echo "  init     - Crea un archivo magicserve.json de plantilla en la carpeta actual"
+    echo "  start    - Inicia todos los servicios del magicserve.json"
+    echo "  stop     - Detiene los servicios del magicserve.json"
+    echo "  stopall  - Busca y detiene TODOS los dominios (sin depender de magicserve.json) y borra todo rastro"
+    echo "  status   - Muestra el estado de los servicios"
+    exit 1
+}
+
+start_server() {
+    local PATH_DIR=$1
+    local DOMAIN=$2
+    local TYPE=$3
+    local PORT=$4
+
+    local PID_FILE="$PIDS_DIR/${DOMAIN}.pid"
+
+    echo "🚀 Iniciando $DOMAIN ($TYPE) en puerto $PORT..."
+
+    # Navegar al directorio del proyecto relativo al script
+    cd "$SCRIPT_DIR/$PATH_DIR" || {
+        echo "❌ Error: Directorio $PATH_DIR no encontrado para $DOMAIN"
+        return
+    }
+
+    if [ "$TYPE" == "node" ]; then
+        nohup npm run dev -- --port $PORT > "$LOGS_DIR/${DOMAIN}.log" 2>&1 &
+        local PID=$!
+        echo $PID > "$PID_FILE"
+        echo "✅ Node corriendo (PID: $PID)"
+    elif [ "$TYPE" == "php" ]; then
+        # El docroot por defecto para php es el directorio actual
+        nohup php -d upload_max_filesize=100M -d post_max_size=100M -S "localhost:$PORT" -t . > "$LOGS_DIR/${DOMAIN}.log" 2>&1 &
+        local PID=$!
+        echo $PID > "$PID_FILE"
+        echo "✅ PHP corriendo (PID: $PID)"
+    else
+        echo "❌ Tipo $TYPE no soportado (usa 'node' o 'php')"
+    fi
+}
+
+start_proxy() {
+    local DOMAIN=$1
+    local PORT=$2
+
+    echo "🔐 Configurando SSL y Proxy Nginx para $DOMAIN -> $PORT..."
+
+    local HOSTS_FILE="/etc/hosts"
+    local NGINX_SERVER_DIR="/opt/homebrew/etc/nginx/servers"
+    local NGINX_CONF="$NGINX_SERVER_DIR/${DOMAIN}.conf"
+    local CERT_DIR="$HOME/.ssl"
+    local CERT="$CERT_DIR/$DOMAIN.pem"
+    local KEY="$CERT_DIR/$DOMAIN-key.pem"
+
+    # Validar si mkcert y nginx están instalados
+    if ! command -v mkcert &> /dev/null; then
+        echo "❌ mkcert no instalado → brew install mkcert"
+        exit 1
+    fi
+    if ! command -v nginx &> /dev/null; then
+        echo "❌ nginx no instalado → brew install nginx"
+        exit 1
+    fi
+
+    # Generar carpeta de certificados si no existe
+    mkdir -p "$CERT_DIR" "$NGINX_SERVER_DIR"
+    sudo chown -R $(whoami) "$CERT_DIR"
+
+    # Instalar mkcert CA si no lo está (suave)
+    mkcert -install > /dev/null 2>&1
+
+    # Generar los certificados para el dominio si no existen
+    if [ ! -f "$CERT" ] || [ ! -f "$KEY" ]; then
+        echo "🆕 Generando certificado SSL para $DOMAIN..."
+        mkcert -cert-file "$CERT" -key-file "$KEY" "$DOMAIN"
+    fi
+
+    # Limpiar en /etc/hosts el dominio y volver a añadirlo
+    sudo sed -i '' "/[[:space:]]$DOMAIN$/d" "$HOSTS_FILE"
+    echo "127.0.0.1    $DOMAIN" | sudo tee -a "$HOSTS_FILE" > /dev/null
+
+    # Crear configuración de Nginx para el dominio
+    sudo tee "$NGINX_CONF" > /dev/null <<EOF
+server {
+    listen 443 ssl;
+    server_name $DOMAIN;
+
+    ssl_certificate     $CERT;
+    ssl_certificate_key $KEY;
+
+    client_max_body_size 100M;
+
+    location / {
+        proxy_pass http://localhost:$PORT;
+        proxy_set_header Host \$host;
+        proxy_set_header X-Real-IP \$remote_addr;
+        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto https;
+
+        # WebSockets Support (Vite HMR)
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade \$http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}
+
+server {
+    listen 80;
+    server_name $DOMAIN;
+    return 301 https://\$host\$request_uri;
+}
+EOF
+}
+
+start_tunnel() {
+    local DOMAIN=$1
+    local PORT=$2
+    local TUNNEL_SUBDOMAIN=$3
+
+    echo "🚇 Iniciando túnel para $DOMAIN en puerto $PORT..."
+    local TUNNEL_PID_FILE="$PIDS_DIR/${DOMAIN}_tunnel.pid"
+
+    # Si pasaron false o null, no hacer nada
+    if [ "$TUNNEL_SUBDOMAIN" == "false" ] || [ "$TUNNEL_SUBDOMAIN" == "null" ] || [ -z "$TUNNEL_SUBDOMAIN" ]; then
+        return
+    fi
+
+    local TUNNEL_LOG="$LOGS_DIR/${DOMAIN}_tunnel.log"
+
+    if [ "$TUNNEL_SUBDOMAIN" == "true" ]; then
+        nohup npx localtunnel --port $PORT > "$TUNNEL_LOG" 2>&1 &
+    else
+        nohup npx localtunnel --port $PORT --subdomain "$TUNNEL_SUBDOMAIN" > "$TUNNEL_LOG" 2>&1 &
+    fi
+
+    local PID=$!
+    echo $PID > "$TUNNEL_PID_FILE"
+    echo "✅ Túnel corriendo (PID: $PID)"
+}
+
+start_all() {
+    echo "🌟 Iniciando todos los servicios desde magicserve.json..."
+
+    local LENGTH=$(jq '. | length' "$CONFIG_FILE")
+    for (( i=0; i<$LENGTH; i++ )); do
+        local PATH_DIR=$(jq -r ".[$i].path" "$CONFIG_FILE")
+        local DOMAIN=$(jq -r ".[$i].domain" "$CONFIG_FILE")
+        local TYPE=$(jq -r ".[$i].type" "$CONFIG_FILE")
+        local PORT=$(jq -r ".[$i].port" "$CONFIG_FILE")
+        local TUNNEL=$(jq -r ".[$i].tunnel // empty" "$CONFIG_FILE")
+
+        start_server "$PATH_DIR" "$DOMAIN" "$TYPE" "$PORT"
+        start_proxy "$DOMAIN" "$PORT"
+
+        if [ -n "$TUNNEL" ]; then
+            start_tunnel "$DOMAIN" "$PORT" "$TUNNEL"
+        fi
+    done
+
+    echo "🔄 Recargando Nginx..."
+    if sudo nginx -t > /dev/null 2>&1; then
+        sudo nginx -s reload || sudo nginx
+        echo "✅ Nginx configurado exitosamente."
+    else
+        echo "❌ Error en configuración de Nginx. Revisa /opt/homebrew/etc/nginx/servers/"
+    fi
+    echo "🎉 ¡Todo listo!"
+}
+
+stop_all() {
+    echo "🛑 Deteniendo todos los servicios..."
+
+    local HOSTS_FILE="/etc/hosts"
+    local NGINX_SERVER_DIR="/opt/homebrew/etc/nginx/servers"
+
+    local LENGTH=$(jq '. | length' "$CONFIG_FILE")
+    for (( i=0; i<$LENGTH; i++ )); do
+        local DOMAIN=$(jq -r ".[$i].domain" "$CONFIG_FILE")
+        local PID_FILE="$PIDS_DIR/${DOMAIN}.pid"
+
+        if [ -f "$PID_FILE" ]; then
+            local PID=$(cat "$PID_FILE")
+            if ps -p $PID > /dev/null; then
+                kill $PID
+                echo "🛑 Servidor para $DOMAIN detenido (PID: $PID)."
+            else
+                echo "⚠️ Proceso para $DOMAIN no encontrado (el archivo PID será limpiado)."
+            fi
+            rm "$PID_FILE"
+        fi
+
+        local TUNNEL_PID_FILE="$PIDS_DIR/${DOMAIN}_tunnel.pid"
+        if [ -f "$TUNNEL_PID_FILE" ]; then
+            local TPID=$(cat "$TUNNEL_PID_FILE")
+            if ps -p $TPID > /dev/null; then
+                kill $TPID
+                echo "🛑 Túnel para $DOMAIN detenido (PID: $TPID)."
+            else
+                echo "⚠️ Proceso de túnel para $DOMAIN no encontrado."
+            fi
+            rm "$TUNNEL_PID_FILE"
+        fi
+
+        # Limpiar de /etc/hosts
+        sudo sed -i '' "/[[:space:]]$DOMAIN$/d" "$HOSTS_FILE"
+
+        # Eliminar configuración de nginx
+        local NGINX_CONF="$NGINX_SERVER_DIR/${DOMAIN}.conf"
+        if [ -f "$NGINX_CONF" ]; then
+            sudo rm "$NGINX_CONF"
+        fi
+    done
+
+    # Recargar nginx
+    if sudo nginx -t > /dev/null 2>&1; then
+        sudo nginx -s reload > /dev/null 2>&1
+    fi
+
+    echo "✅ Todo detenido."
+}
+
+status() {
+    echo "📊 Estado de los servicios:"
+    local LENGTH=$(jq '. | length' "$CONFIG_FILE")
+    for (( i=0; i<$LENGTH; i++ )); do
+        local DOMAIN=$(jq -r ".[$i].domain" "$CONFIG_FILE")
+        local PID_FILE="$PIDS_DIR/${DOMAIN}.pid"
+
+        if [ -f "$PID_FILE" ]; then
+            local PID=$(cat "$PID_FILE")
+            if ps -p $PID > /dev/null; then
+                 echo "🟢 $DOMAIN: Corriendo (PID: $PID)"
+            else
+                 echo "🔴 $DOMAIN: Archivo PID existe pero el proceso no está corriendo"
+            fi
+        else
+            echo "⚪️ $DOMAIN: Detenido"
+        fi
+
+        local TUNNEL_PID_FILE="$PIDS_DIR/${DOMAIN}_tunnel.pid"
+        if [ -f "$TUNNEL_PID_FILE" ]; then
+            local TPID=$(cat "$TUNNEL_PID_FILE")
+            if ps -p $TPID > /dev/null; then
+                 echo "  ↳ 🚇 Túnel expuesto (PID: $TPID)"
+            else
+                 echo "  ↳ 🔴 Túnel: Archivo PID existe pero no está corriendo"
+            fi
+        fi
+    done
+}
+
+stop_all_global() {
+    echo "🔥 STOPALL: Buscando y eliminando TODOS los dominios y rastros de la computadora..."
+    echo ""
+
+    local HOSTS_FILE="/etc/hosts"
+    local NGINX_SERVER_DIR="/opt/homebrew/etc/nginx/servers"
+    local CERT_DIR="$HOME/.ssl"
+    local FOUND_SOMETHING=false
+
+    # ─── 1. Limpiar archivos .pid locales ───
+    echo "🔍 Buscando archivos .pid locales..."
+    if [ -d "$PIDS_DIR" ]; then
+        for PID_FILE in "$PIDS_DIR"/*.pid; do
+            [ -f "$PID_FILE" ] || continue
+            FOUND_SOMETHING=true
+            local PID=$(cat "$PID_FILE")
+            local BASENAME=$(basename "$PID_FILE")
+            local DOMAIN_NAME=${BASENAME%.pid}
+
+        if ps -p $PID > /dev/null 2>&1; then
+            kill $PID 2>/dev/null
+            echo "  🛑 Proceso detenido: $DOMAIN_NAME (PID: $PID)"
+        else
+            echo "  ⚠️  Proceso ya no existía: $DOMAIN_NAME (PID: $PID)"
+        fi
+        done
+    fi
+    if [ "$FOUND_SOMETHING" = false ]; then
+        echo "  ✅ No se encontraron archivos .pid"
+    fi
+
+    # ─── 2. Matar TODOS los servidores PHP built-in de la computadora ───
+    echo ""
+    echo "🔍 Buscando servidores PHP built-in (php -S)..."
+    local PHP_PIDS=$(pgrep -f "php -S" 2>/dev/null)
+    if [ -n "$PHP_PIDS" ]; then
+        echo "$PHP_PIDS" | while read PID; do
+            local CMD=$(ps -p $PID -o args= 2>/dev/null)
+            kill $PID 2>/dev/null
+            echo "  🛑 PHP detenido (PID: $PID) → $CMD"
+        done
+    else
+        echo "  ✅ No se encontraron servidores PHP"
+    fi
+
+    # ─── 3. Matar TODOS los servidores Node de desarrollo ───
+    echo ""
+    echo "🔍 Buscando servidores Node de desarrollo (vite, next, nuxt, webpack)..."
+    local NODE_PIDS=$(pgrep -f "(vite|next dev|nuxt|webpack-dev-server|node.*dev)" 2>/dev/null)
+    if [ -n "$NODE_PIDS" ]; then
+        echo "$NODE_PIDS" | while read PID; do
+            local CMD=$(ps -p $PID -o args= 2>/dev/null | head -c 120)
+            kill $PID 2>/dev/null
+            echo "  🛑 Node detenido (PID: $PID) → $CMD"
+        done
+    else
+        echo "  ✅ No se encontraron servidores Node de desarrollo"
+    fi
+
+    # ─── 3.5. Matar procesos de localtunnel ───
+    echo ""
+    echo "🔍 Buscando procesos de localtunnel..."
+    local LT_PIDS=$(pgrep -f "localtunnel" 2>/dev/null)
+    if [ -n "$LT_PIDS" ]; then
+        echo "$LT_PIDS" | while read PID; do
+            kill $PID 2>/dev/null
+            echo "  🛑 localtunnel detenido (PID: $PID)"
+        done
+    else
+        echo "  ✅ No se encontraron procesos de localtunnel"
+    fi
+
+    # ─── 4. Eliminar TODAS las configuraciones de nginx en servers/ ───
+    echo ""
+    echo "🔍 Buscando configuraciones de Nginx..."
+    FOUND_SOMETHING=false
+    if [ -d "$NGINX_SERVER_DIR" ]; then
+        for CONF_FILE in "$NGINX_SERVER_DIR"/*.conf; do
+            [ -f "$CONF_FILE" ] || continue
+            FOUND_SOMETHING=true
+            local CONF_NAME=$(basename "$CONF_FILE")
+            sudo rm -f "$CONF_FILE"
+            echo "  🗑️  Eliminado: $CONF_NAME"
+        done
+    fi
+    if [ "$FOUND_SOMETHING" = false ]; then
+        echo "  ✅ No se encontraron configuraciones de Nginx"
+    fi
+
+    # ─── 5. Limpiar /etc/hosts (TODAS las entradas custom de 127.0.0.1) ───
+    echo ""
+    echo "🔍 Limpiando /etc/hosts (todas las entradas custom)..."
+    # Contar entradas de 127.0.0.1 que NO sean localhost
+    local HOSTS_BEFORE=$(grep -c '^127\.0\.0\.1' "$HOSTS_FILE" 2>/dev/null || echo 0)
+    # Eliminar todas las líneas 127.0.0.1 que NO sean localhost
+    sudo sed -i '' '/^127\.0\.0\.1[[:space:]]\{1,\}localhost$/!{ /^127\.0\.0\.1/d; }' "$HOSTS_FILE"
+    local HOSTS_AFTER=$(grep -c '^127\.0\.0\.1' "$HOSTS_FILE" 2>/dev/null || echo 0)
+    local REMOVED=$((HOSTS_BEFORE - HOSTS_AFTER))
+    if [ $REMOVED -gt 0 ]; then
+        echo "  🗑️  Se eliminaron $REMOVED entradas custom de /etc/hosts"
+    else
+        echo "  ✅ No se encontraron entradas custom en /etc/hosts"
+    fi
+
+    # ─── 6. Eliminar TODO el contenido de ~/.ssl/ ───
+    echo ""
+    echo "🔍 Limpiando $CERT_DIR (todos los archivos)..."
+    if [ -d "$CERT_DIR" ] && [ "$(ls -A "$CERT_DIR" 2>/dev/null)" ]; then
+        local SSL_COUNT=$(ls -1 "$CERT_DIR" | wc -l | tr -d ' ')
+        rm -rf "$CERT_DIR"/*
+        echo "  🗑️  Se eliminaron $SSL_COUNT archivos de $CERT_DIR"
+    else
+        echo "  ✅ No se encontraron archivos en $CERT_DIR"
+    fi
+
+    # ─── 7. Eliminar logs ───
+    echo ""
+    echo "🔍 Limpiando logs..."
+    if [ -d "$LOGS_DIR" ] && [ "$(ls -A "$LOGS_DIR" 2>/dev/null)" ]; then
+        rm -f "$LOGS_DIR"/*
+        echo "  🗑️  Logs eliminados"
+    else
+        echo "  ✅ No se encontraron logs"
+    fi
+
+    # ─── 8. Detener Nginx completamente ───
+    echo ""
+    echo "🔍 Deteniendo Nginx..."
+    if pgrep -x nginx > /dev/null 2>&1; then
+        sudo nginx -s stop > /dev/null 2>&1
+        echo "  🛑 Nginx detenido"
+    else
+        echo "  ✅ Nginx no estaba corriendo"
+    fi
+
+    echo ""
+    echo "🧹 ¡Todo limpio! No queda rastro."
+}
+
+init_config() {
+    if [ -f "$CONFIG_FILE" ]; then
+        echo "⚠️  El archivo magicserve.json ya existe en este directorio."
+        exit 1
+    fi
+    cat <<EOF > "$CONFIG_FILE"
+[
+    {
+        "path": "../tu-proyecto-frontal",
+        "domain": "tu-proyecto.test",
+        "type": "node",
+        "port": 3000
+    },
+    {
+        "path": "../tu-api-backend",
+        "domain": "api.tu-proyecto.test",
+        "type": "php",
+        "port": 3001,
+        "tunnel": "mi-super-api-dev"
+    }
+]
+EOF
+    echo "✅ Archivo magicserve.json base generado exitosamente."
+}
+
+case "$ACTION" in
+    init)
+        init_config
+        ;;
+    start)
+        start_all
+        ;;
+    stop)
+        stop_all
+        ;;
+    stopall)
+        stop_all_global
+        ;;
+    status)
+        status
+        ;;
+    *)
+        usage
+        ;;
+esac