magicserve 1.2.6 → 2.0.2

package/README.es.md

@@ -2,7 +2,9 @@
 
 *[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`).
+Magicserve es una herramienta CLI para gestionar entornos de desarrollo web locales. Levanta automáticamente un Reverse Proxy (Nginx) con HTTPS para múltiples servicios locales a la vez, genera certificados SSL vía `mkcert` y le asigna a cada uno un dominio dinámico (ej. `tu-proyecto.test`), además de URLs públicas opcionales vía `localtunnel`.
+
+> **Tú levantas tus propios servidores.** Magicserve **no** inicia ni detiene tus apps. Tú levantas lo que quieras (Node, PHP, Python, Go, …) en los puertos que listes en `magicserve.json`, y Magicserve enlaza el dominio HTTPS, el certificado y el túnel a ese puerto.
 
 ## Requisitos
 
@@ -45,20 +47,16 @@ Este comando creará automáticamente un archivo base llamado **`magicserve.json
 
 ### 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:
+Tu directorio central mapea dominios a los puertos locales de las apps que tú mismo levantas. 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"
     }
@@ -66,13 +64,11 @@ Tu directorio central gestiona y levanta las aplicaciones referenciadas dentro d
 ```
 
 **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).
+- **`port`**: El puerto local donde está escuchando **tu** servidor. Magicserve hace proxy del dominio a `localhost:<port>`; tú eres responsable de levantar ese servidor.
+- **`tunnel`**: *(Opcional)* Subdominio para exponer tu puerto a internet público a través de `localtunnel` (Ej. webhooks de Mercado Libre o pruebas móviles). Usa `true` para un subdominio aleatorio.
 
-Una vez configurado o modificado a tu gusto, utiliza los comandos de control.
+Una vez configurado a tu gusto, levanta tus propios servidores en esos puertos y utiliza los comandos de control.
 
 ## Comandos disponibles
 
@@ -88,8 +84,8 @@ flowchart TD
     subgraph Tu Computadora Local
         Nginx(Nginx Proxy Inverso SSL)
         LT(LocalTunnel Túnel Reverso)
-        Node((Servidor Node\nEj. 3000))
-        PHP((Servidor PHP\nEj. 3001))
+        Node((Tu Servidor\nEj. 3000))
+        PHP((Tu Servidor\nEj. 3001))
     end
 
     Dev -- "https://tu-proyecto.test" --> Nginx
@@ -100,16 +96,27 @@ flowchart TD
     LT -- "Túnel" --> PHP
 ```
 
+> Magicserve gestiona las partes de infraestructura (proxy Nginx, SSL, hosts, túnel). Los servidores detrás de los puertos los inicias y detienes tú.
 
 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.
+- **`magicserve start`**: Para cada dominio genera el certificado SSL si hace falta, agrega la entrada en `/etc/hosts`, escribe el proxy HTTPS de Nginx hacia `localhost:<port>` y abre los túneles configurados. (Levanta tus servidores antes o después — Magicserve no los inicia.)
+- **`magicserve stop`**: Quita los proxys de Nginx y las entradas de `/etc/hosts` y cierra los túneles de los dominios de tu `magicserve.json`. Tus servidores siguen corriendo.
+- **`magicserve status`**: Te muestra si hay un servidor escuchando en el puerto de cada dominio, más el estado y la URL pública de los túneles.
+- **`magicserve stopall`**: Comando de emergencia. Destruye TODAS las configuraciones de proxy de Nginx, túneles, certificados SSL y entradas custom de `localhost` en todo el sistema, restaurando tu computadora. (Ya no mata tus servidores de apps — esos los gestionas tú.)
 
 ---
 
+### Novedades en v2.0.0 🔌 (Breaking)
+
+- **Tú levantas tus propios servidores.** Magicserve ya no inicia procesos `node`/`php` — solo configura el proxy HTTPS de Nginx, el certificado SSL, la entrada en `/etc/hosts` y el túnel opcional apuntando al puerto que tú levantas (funciona con **cualquier** stack: Node, PHP, Python, Go, …).
+- **Config más simple.** `magicserve.json` ahora solo lleva `domain` + `port` (+ `tunnel` opcional). Se eliminaron las propiedades `path` y `type`.
+- **`stop` no afecta a tus apps.** Solo retira el proxy y los túneles; tus servidores siguen corriendo.
+- **`status` revisa el puerto.** Ahora reporta si hay algo escuchando en cada puerto (vía `lsof`) en lugar de rastrear el PID de un servidor.
+- **`stopall` ya no mata tus servidores de apps** (esos los gestionas tú); sigue purgando todos los proxys, túneles, certificados y entradas custom de `hosts`.
+
+> **Migrar desde v1.x:** elimina `path` y `type` de cada entrada de tu `magicserve.json`, y levanta tus servidores tú mismo antes/después de ejecutar `magicserve start`.
+
 ### 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).

package/README.md

@@ -2,7 +2,9 @@
 
 *[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`).
+Magicserve is a CLI tool for managing local web development environments. It automatically sets up a Reverse Proxy (Nginx) with HTTPS for multiple local services at once, generates SSL certificates via `mkcert`, and assigns each a dynamic local domain (e.g. `your-project.test`) — plus optional public `localtunnel` URLs.
+
+> **You run your own servers.** Magicserve does **not** start or stop your apps. Launch whatever you want (Node, PHP, Python, Go, …) on the ports listed in `magicserve.json`, and Magicserve wires the HTTPS domain, certificate, and tunnel to that port.
 
 ## Requirements
 
@@ -45,20 +47,16 @@ This command will automatically create a base **`magicserve.json`** file in the
 
 ### Configuration File: `magicserve.json`
 
-Your central directory manages and starts the applications referenced within the **`magicserve.json`**. Its structure is this simple:
+Your central directory maps domains to the local ports of the apps you run yourself. 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"
     }
@@ -66,13 +64,11 @@ Your central directory manages and starts the applications referenced within the
 ```
 
 **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).
+- **`port`**: The local port where **your** server is listening. Magicserve proxies the domain to `localhost:<port>`; you are responsible for starting that server.
+- **`tunnel`**: *(Optional)* Subdomain to securely expose your port to the public internet via `localtunnel` (Great for testing third-party Webhooks like Mercado Libre or local mobile testing). Use `true` for a random subdomain.
 
-Once configured or modified to your liking, you can use the control commands.
+Once configured to your liking, start your own servers on those ports, then use the control commands below.
 
 ## Available Commands
 
@@ -88,8 +84,8 @@ flowchart TD
     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))
+        Node((Your Server\ne.g. 3000))
+        PHP((Your Server\ne.g. 3001))
     end
 
     Dev -- "https://your-project.test" --> Nginx
@@ -100,15 +96,27 @@ flowchart TD
     LT -- "Tunnel" --> PHP
 ```
 
+> Magicserve manages the dashed parts (Nginx proxy, SSL, hosts, tunnel). The servers behind the ports are started and stopped by you.
+
 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.
+- **`magicserve start`**: For every domain, generates an SSL certificate if needed, adds the `/etc/hosts` entry, writes the Nginx HTTPS proxy to `localhost:<port>`, and opens any configured tunnels. (Start your own servers first or afterward — Magicserve does not launch them.)
+- **`magicserve stop`**: Removes the Nginx proxies and `/etc/hosts` entries and closes the tunnels for the domains in your `magicserve.json`. Your servers keep running.
+- **`magicserve status`**: Shows whether a server is currently listening on each domain's port, plus the status and public URL of any tunnels.
+- **`magicserve stopall`**: Emergency command. Destroys ALL Nginx proxy configs, tunnels, SSL certificates and custom `localhost` entries system-wide, restoring your machine's clean state. (It no longer kills your app servers — those are yours to manage.)
 
 ---
 
+### Features in v2.0.0 🔌 (Breaking)
+
+- **You run your own servers.** Magicserve no longer launches `node`/`php` processes — it only sets up the Nginx HTTPS proxy, SSL certificate, `/etc/hosts` entry and optional tunnel pointing at the port you bring up yourself (works with **any** stack: Node, PHP, Python, Go, …).
+- **Simpler config.** `magicserve.json` now takes only `domain` + `port` (+ optional `tunnel`). The `path` and `type` properties have been removed.
+- **`stop` is non-destructive to your apps.** It tears down the proxy and tunnels only; your servers keep running.
+- **`status` probes the port.** It now reports whether something is listening on each port (via `lsof`) instead of tracking a server PID.
+- **`stopall` no longer kills app servers** (those are yours to manage); it still purges all proxies, tunnels, certificates and custom `hosts` entries.
+
+> **Migrating from v1.x:** remove `path` and `type` from each entry in your `magicserve.json`, and start your servers yourself before/after running `magicserve start`.
+
 ### 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).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "magicserve",
-  "version": "1.2.6",
-  "description": "Script to run local environments via magicserve.json",
+  "version": "2.0.2",
+  "description": "CLI to wire local HTTPS domains, SSL and tunnels to ports you run yourself",
   "files": [
     "run.sh",
     "package.json"

package/run.sh

@@ -45,45 +45,13 @@ usage() {
     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"
+    echo "  start    - Configura proxy Nginx (HTTPS) y túneles para los dominios del magicserve.json"
+    echo "  stop     - Detiene los proxys y túneles del magicserve.json (no toca tus servidores)"
+    echo "  stopall  - Borra TODOS los proxys, túneles, certificados y entradas de hosts (sin depender de magicserve.json)"
+    echo "  status   - Muestra si hay un servidor escuchando en cada puerto y el estado de los túneles"
     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
@@ -164,6 +132,7 @@ start_tunnel() {
 
     echo "🚇 Iniciando túnel para $DOMAIN en puerto $PORT..."
     local TUNNEL_PID_FILE="$PIDS_DIR/${DOMAIN}_tunnel.pid"
+    local TUNNEL_URL_FILE="$PIDS_DIR/${DOMAIN}_tunnel.url"
 
     # Si pasaron false o null, no hacer nada
     if [ "$TUNNEL_SUBDOMAIN" == "false" ] || [ "$TUNNEL_SUBDOMAIN" == "null" ] || [ -z "$TUNNEL_SUBDOMAIN" ]; then
@@ -174,27 +143,41 @@ start_tunnel() {
 
     if [ "$TUNNEL_SUBDOMAIN" == "true" ]; then
         nohup npx localtunnel --port $PORT > "$TUNNEL_LOG" 2>&1 &
+        local PID=$!
+        echo $PID > "$TUNNEL_PID_FILE"
+        echo "✅ Túnel corriendo (PID: $PID)"
+        # Esperar a que localtunnel imprima la URL dinámica
+        echo "⏳ Esperando URL del túnel..."
+        sleep 4
+        local URL=$(grep -o 'https://[^ ]*' "$TUNNEL_LOG" 2>/dev/null | head -1)
+        if [ -n "$URL" ]; then
+            echo "$URL" > "$TUNNEL_URL_FILE"
+            echo "🌐 URL pública del túnel: $URL"
+        else
+            echo "⚠️  No se pudo obtener la URL del túnel aún. Revisa: $TUNNEL_LOG"
+        fi
     else
         nohup npx localtunnel --port $PORT --subdomain "$TUNNEL_SUBDOMAIN" > "$TUNNEL_LOG" 2>&1 &
+        local PID=$!
+        echo $PID > "$TUNNEL_PID_FILE"
+        local URL="https://${TUNNEL_SUBDOMAIN}.loca.lt"
+        echo "$URL" > "$TUNNEL_URL_FILE"
+        echo "✅ Túnel corriendo (PID: $PID)"
+        echo "🌐 URL pública del túnel: $URL"
     fi
-
-    local PID=$!
-    echo $PID > "$TUNNEL_PID_FILE"
-    echo "✅ Túnel corriendo (PID: $PID)"
 }
 
 start_all() {
-    echo "🌟 Iniciando todos los servicios desde magicserve.json..."
+    echo "🌟 Configurando proxys y túneles desde magicserve.json..."
+    echo "💡 Recuerda: tú debes levantar tus servidores (node/php/python/etc) en los puertos indicados."
+    echo ""
 
     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
@@ -213,7 +196,7 @@ start_all() {
 }
 
 stop_all() {
-    echo "🛑 Deteniendo todos los servicios..."
+    echo "🛑 Deteniendo proxys y túneles..."
 
     local HOSTS_FILE="/etc/hosts"
     local NGINX_SERVER_DIR="/opt/homebrew/etc/nginx/servers"
@@ -221,20 +204,9 @@ stop_all() {
     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"
+        local TUNNEL_URL_FILE="$PIDS_DIR/${DOMAIN}_tunnel.url"
         if [ -f "$TUNNEL_PID_FILE" ]; then
             local TPID=$(cat "$TUNNEL_PID_FILE")
             if ps -p $TPID > /dev/null; then
@@ -244,6 +216,7 @@ stop_all() {
                 echo "⚠️ Proceso de túnel para $DOMAIN no encontrado."
             fi
             rm "$TUNNEL_PID_FILE"
+            rm -f "$TUNNEL_URL_FILE"
         fi
 
         # Limpiar de /etc/hosts
@@ -261,7 +234,7 @@ stop_all() {
         sudo nginx -s reload > /dev/null 2>&1
     fi
 
-    echo "✅ Todo detenido."
+    echo "✅ Proxys y túneles detenidos. (Tus servidores siguen corriendo, deténlos tú mismo)."
 }
 
 status() {
@@ -269,24 +242,28 @@ status() {
     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"
+        local PORT=$(jq -r ".[$i].port" "$CONFIG_FILE")
 
-        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
+        # No gestionamos el proceso del servidor: comprobamos si algo escucha en el puerto
+        local LISTENER=$(lsof -nP -iTCP:$PORT -sTCP:LISTEN -t 2>/dev/null | head -1)
+        if [ -n "$LISTENER" ]; then
+            echo "🟢 $DOMAIN → localhost:$PORT (servidor escuchando, PID: $LISTENER)"
         else
-            echo "⚪️ $DOMAIN: Detenido"
+            echo "⚪️ $DOMAIN → localhost:$PORT (nada escuchando — levanta tu servidor)"
         fi
 
         local TUNNEL_PID_FILE="$PIDS_DIR/${DOMAIN}_tunnel.pid"
+        local TUNNEL_URL_FILE="$PIDS_DIR/${DOMAIN}_tunnel.url"
         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)"
+                local TURL=""
+                [ -f "$TUNNEL_URL_FILE" ] && TURL=$(cat "$TUNNEL_URL_FILE")
+                if [ -n "$TURL" ]; then
+                    echo "  ↳ 🚇 Túnel activo (PID: $TPID) → 🌐 $TURL"
+                else
+                    echo "  ↳ 🚇 Túnel activo (PID: $TPID)"
+                fi
             else
                  echo "  ↳ 🔴 Túnel: Archivo PID existe pero no está corriendo"
             fi
@@ -325,35 +302,11 @@ stop_all_global() {
         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
+    # NOTA: Magicserve ya no lanza servidores (node/php/python), así que tampoco
+    # los mata aquí. Tus servidores los gestionas tú. Solo limpiamos lo que
+    # Magicserve crea: túneles, configs de nginx, /etc/hosts, certificados y logs.
 
-    # ─── 3.5. Matar procesos de localtunnel ───
+    # ─── 2. Matar procesos de localtunnel ───
     echo ""
     echo "🔍 Buscando procesos de localtunnel..."
     local LT_PIDS=$(pgrep -f "localtunnel" 2>/dev/null)
@@ -441,15 +394,11 @@ init_config() {
     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"
     }