Blog

Cómo conectar Antigravity a un WordPress autoalojado con un servidor MCP en Node.js (sin plugins)
Si tienes un sitio WordPress alojado de forma privada (fuera de WordPress.com) y quieres gestionarlo directamente desde Antigravity —publicar artículos, editar páginas, consultar categorías o buscar contenido—, no necesitas instalar ningún plugin adicional en tu WordPress.

WordPress incluye de serie su propia REST API (/wp-json/wp/v2) y un sistema nativo de Contraseñas de aplicación (Application Passwords). Combinando ambas piezas con un pequeño servidor MCP (Model Context Protocol) escrito en Node.js y JavaScript, Antigravity puede conectarse de forma segura a tu web. De hecho, este mismo artículo se ha publicado así.

1. Qué necesitas en tu WordPress: usuario y contraseña de aplicación

Para que el servidor MCP pueda autenticar peticiones de escritura (crear o editar entradas, páginas o categorías) sin exponer tu contraseña principal, debes generar una Contraseña de aplicación:
1. Accede al panel de administración de tu WordPress (https://tudominio.com/wp-admin).
2. (Opcional recomendado) Ve a Usuarios → Añadir nuevo y crea un usuario dedicado para la integración (por ejemplo, con rol Editor si solo va a gestionar contenido, o Administrador si necesitas acceso completo).
3. Entra en Usuarios → Perfil (o edita el perfil del usuario que acabas de crear).
4. Desplázate hasta la sección Contraseñas de aplicación.
5. Escribe un nombre identificativo, por ejemplo Antigravity MCP, y haz clic en Añadir nueva contraseña de aplicación.
6. Copia inmediatamente la contraseña generada (tiene un formato de bloques separados por espacios, como xxxx xxxx xxxx xxxx xxxx xxxx), ya que WordPress solo la muestra una vez.
Con esto ya tienes los tres datos necesarios para la conexión:
- WP_BASE_URL: la URL raíz de tu sitio (por ejemplo, https://nireleku.com).
- WP_USERNAME: el nombre de usuario de acceso en WordPress (no el nombre de la contraseña de aplicación).
- WP_APP_PASSWORD: la contraseña de aplicación generada.
2. El servidor MCP en Node.js y JavaScript

El servidor MCP actúa como puente entre Antigravity (mediante transporte stdio) y la REST API de WordPress. Con Node.js moderno ni siquiera hacen falta dependencias pesadas para HTTP: el propio fetch nativo gestiona las peticiones.

Las piezas principales del proyecto son:
- @modelcontextprotocol/sdk y zod: para definir el servidor MCP, validar los parámetros de entrada de cada herramienta y exponerlas por StdioServerTransport.
- Cliente WordPress: construye las URLs bajo /wp-json/wp/v2/..., añade la cabecera Authorization: Basic ... codificando WP_USERNAME:WP_APP_PASSWORD en Base64 y devuelve los resultados junto con la paginación (X-WP-Total y X-WP-TotalPages).
- Herramientas MCP: funciones como wp_get_site_info, wp_list_posts, wp_create_post, wp_update_post, wp_delete_post, gestión de páginas, categorías, etiquetas, medios y búsqueda global (wp_search).
3. Conectar el servidor en Antigravity (mcp_config.json)

Una vez creado el servidor Node.js, solo hay que registrarlo en el archivo mcp_config.json de Antigravity indicando el comando node, la ruta al archivo de entrada y las variables de entorno:
```
{
  "mcpServers": {
    "mi-wordpress": {
      "command": "node",
      "args": ["C:/ruta/al/proyecto/src/index.js"],
      "env": {
        "WP_BASE_URL": "https://nireleku.com",
        "WP_USERNAME": "tu_usuario",
        "WP_APP_PASSWORD": "xxxx xxxx xxxx xxxx xxxx xxxx"
      }
    }
  }
}
```
4. Prueba superada

Si estás leyendo esta entrada publicada en nireleku.com, significa que el servidor MCP en Node.js se ha autenticado correctamente contra la REST API de WordPress usando la contraseña de aplicación y ha ejecutado wp_create_post sin necesidad de ningún plugin intermedio.
2026-11-14
Cómo solucionar el error de «Permiso Denegado» en carpetas compartidas de VirtualBox con Ubuntu
El problema: El muro de los permisos

Configurar carpetas compartidas entre un sistema anfitrión (Windows/Mac) y una máquina virtual con Ubuntu es una de las funciones más útiles de VirtualBox. Sin embargo, muchos usuarios se topan con un obstáculo frustrante: la carpeta aparece en el sistema, pero al intentar abrirla, Ubuntu lanza un error de «Permiso denegado».
Esto ocurre porque, por seguridad, VirtualBox restringe el acceso a estas carpetas únicamente a los miembros del grupo de sistema llamado vboxsf.

La Solución: Pasos para habilitar el acceso

Para otorgar a tu usuario los permisos necesarios, sigue estos tres sencillos pasos:

1. Identifica y añade tu usuario al grupo

No necesitas ser un experto en la terminal. Solo abre una consola (Ctrl + Alt + T) y escribe el siguiente comando:
```
sudo adduser $USER vboxsf
```
La variable $USER tomará automáticamente tu nombre de usuario actual. Si quieres añadir a otro usuario específico, simplemente sustituye $USER por el nombre deseado.

2. Reinicia para aplicar cambios

Este es el paso que la mayoría olvida. Los permisos de grupo en Linux no se actualizan en tiempo real para la sesión activa. Para que Ubuntu reconozca que ahora perteneces a vboxsf, debes:
- Cerrar sesión y volver a iniciarla.
- O, idealmente, reiniciar la máquina virtual.
3. Localiza tus archivos

Una vez reiniciado, encontrarás tu carpeta compartida en la ruta:
/media/sf_[Nombre_de_tu_carpeta]

Si seleccionaste la opción «Auto-montar» al configurar la carpeta en VirtualBox, aparecerá automáticamente en tu barra lateral del gestor de archivos (Nautilus).

¿Sigues sin ver la carpeta?

Si después de seguir estos pasos la carpeta no aparece, asegúrate de haber instalado las Guest Additions (Complementos del Invitado). Puedes hacerlo desde el menú de la ventana de la MV en:
Dispositivos > Insertar imagen de CD de las Guest Additions.
2026-02-23
Cómo instalar Google Antigravity en Arch Linux
Google Antigravity permite el desarrollo agéntico con Gemini 3. Para usuarios de Arch Linux, existen diferentes métodos de instalación.

Arch User Repository (AUR)

La comunidad ha empaquetado esta herramienta. Es la opción recomendada para mantener el IDE actualizado.
- Con un asistente: Si usa paru, solo necesita este comando:
  bash
```
paru -S antigravity
```
- Instalación manual:
  Clona el paquete: git clone https://aur.archlinux.org.
  Compila: makepkg -si.
Script Comunitario «Antigravity Installer»

Este script de GitHub adapta los paquetes oficiales de Google (.deb) a la estructura de Arch Linux.
Obtén el script de GitHub:
```
git clone https://github.com/apipa12/antigravity-installer.git
cd antigravity-installer
```
Ejecútalo: ./antigravity-installer.sh. El script descarga el binario, verifica su firma y crea accesos directos en /opt/antigravity.

Formato Portable (Tarball)

Se puede usar el archivo comprimido oficial.
- Visita la página de descargas de Antigravity y elige el archivo .tar.gz.
- Descomprímelo en tu carpeta home y ejecuta el binario directamente.
Compatibilidad con Flatpak

Lamentablemete no existe aún una versión oficial en Flathub. Google prioriza sus propios repositorios nativos. Se recomienda usar el AUR para evitar problemas de dependencias con el motor Electron que utiliza el IDE.
2026-02-03
Cómo Limpiar tu Sistema Arch Linux: Guía Definitiva de Pacman
Mantener una distribución «Rolling Release» no se trata solo de actualizar; también hay que saber cuándo tirar la basura. Si notas que tu disco duro se está llenando sin motivo aparente, probablemente sea el caché de paquetes o las dependencias huérfanas.

Aquí te enseño cómo hacer una limpieza profunda de forma segura.

1. Elimina el Caché de Paquetes (El «Devorador» de Espacio)

Cada vez que descargas un programa, pacman guarda una copia en /var/cache/pacman/pkg/. Esto es útil para hacer un downgrade, pero ocupa gigabytes rápidamente.

La opción rápida (Limpieza básica)

Para eliminar los paquetes antiguos que ya no están instalados, usa el comando detallado en la documentación de pacman en Arch Wiki:
```
sudo pacman -Sc
```
La opción radical

Si tienes poco espacio y no planeas volver a versiones anteriores de ningún software, puedes vaciar la carpeta por completo:
```
sudo pacman -Scc
```
2. Despídete de los Paquetes Huérfanos

A veces instalas un programa que requiere de otros para funcionar. Cuando borras el programa principal, esas dependencias se quedan «viviendo» en tu sistema sin hacer nada. Se les llama huérfanos.

Para localizarlos y eliminarlos de un plumazo, usa este comando recomendado por expertos en comunidades de Linux:
```
sudo pacman -Rns $(pacman -Qdtq)
```
Nota: Si el sistema dice «error: no se han seleccionado objetivos», ¡felicidades! Estás libre de huérfanos.

3. Limpieza Inteligente con Paccache

Si prefieres un enfoque profesional, instala las pacman-contrib y usa paccache. Esta herramienta mantiene solo las últimas 3 versiones de cada paquete (por seguridad) y borra el resto.
```
sudo paccache -r
```
Conclusión: El hábito hace al SysAdmin

Ejecutar estos comandos una vez al mes mantendrá tu sistema ligero y rápido. Recuerda siempre verificar qué estás borrando antes de confirmar con una Y.
2026-02-03
Cómo gestionar errores de la base de datos con Prisma en Express en nuestra API
Es importante gestionar adecuadamente los errores que son generados por nuestra base de datos gestionada con Prisma cuando creamos una API para nuestra aplicación en JavaScript o TypeScript.

Como primera opción podemos usar los bloques try-catch. Podemos envolver las consultas a la base de datos en un try-catch y gestionar cualquier error que pueda ocurrir. Por ejemplo:
```
try {
  const result = await prisma.users.create({
    data: { name: 'José' }
  });
} catch (err) {
  console.error(err);
  return res.status(500).send({ error: 'Ocurrió un error creando el usuario.' });
}
```
Otra opción es valerse del método catch propio de la llamada de Prisma a la consulta y gestionar en él cualquier error que suceda accediendo a la base de datos. Por ejemplo:
```
prisma.users.create({
  data: { name: 'José' }
}).catch((err) => {
  console.error(err);
  return res.status(500).send({ error: 'Ocurrió un error creando el usuario.' });
});
```
Como última opción, podemos crear un middleware en Express para gestionar estos errores que puedan suceder en nuestras rutas. Aquí necesitaremos hacer uso de una función next() en nuestras rutas y enviar el error a través de ella. El middleware podría ser algo como:
```
app.use((err, req, res, next) => {
  console.error(err);
  return res.status(500).send({ error: err.message });
});
```
y en la ruta haremos algo como:
```
next(new Error("Ocurrió un error creando el usuario.")
```
Esto es todo. Espero que algunas de estas opciones te resulten de utilidad. Señalar que en Express 5 el middleware de errores promete gestionar también los errores de fuentes asíncronas.

Para saber más:
2022-12-31
Cómo borrar todos los node_modules en la carpeta de desarrollo
Cuando estamos programando en JavaScript u otro lenguaje que haga uso de nodejs se crea un subdirectorio en nuestra carpeta de desarrollo llamada node_modules. En esta carpeta, si nos atrevemos a echar un vistazo en su interior, podemos encontrar decenas de otros subdirectorios que corresponden a los diferentes módulos que nuestra aplicación necesitara para funcionar.

En principio no hay ningún problema con esto, pero en algún momento, tras empezar decenas de proyectos o hacer diferentes pruebas de concepto nos encontramos con que existen demasiados de estos directorios llamados node_modules y quizás nos planteemos el borrarlos.

Por la propia estructura de los archivos de node_modules los archivos en ella tienen varias características. Algunos de los módulos que podemos encontrar estarán duplicados en otros proyectos en los que también estemos trabajando, ocupando un espacio innecesario en disco mientras los proyectos estén ahí inertes. Una vez retomemos el trabajo con ellos en el caso de que node_modules no exista podemos forzar a reinstalar los módulos necesarios en el proyecto con un npm install.

Además, siendo la mayoría de los archivos en node_modules ficheros de código en JavaScript o TypeScript, estos no suelen tener un tamaño muy grande, buena parte de ellos en el rango de kilobytes o menos pero su almacenamiento en disco implica que pueden ocupar un clúster entero, siendo fácilmente que hoy en día encontremos clústeres de de 8 kilobytes o incluso 16kb siendo esto es muy muy ineficiente. El sistema operativo inteligentemente almacenará estos archivos en el $MFT donde los archivos pequeños ocuparán solo lo que es necesario, pero su acceso y modificación es más lenta y fomenta la fragmentación del $MFT teniendo esto incluso un impacto global en el sistema.

Podemos apreciar esto cuando tratamos de borrar manualmente una carpeta node_modules mediante el Explorador de Windows y observamos lo lento que puede llegar a ser borrar los cientos de archivos y carpetas que se alojan allí. Por ejemplo, un proyecto recién iniciado de Nestjs tiene casi 30.000 ficheros y casi 3.000 subdirectorios y ocupa unos 265 megabytes. Incluso con almacenamiento SSD borrar node_modules para este proyecto requiere en mi equipo alrededor de 30 segundos.

Una vez visto que el directorio node_modules en aquellos proyectos inertes ocupa un considerable espacio, aloja multitud de archivos duplicados y fomenta la fragmentación del $MFT, borrar node_modules donde se requiera es seguramente una buena decisión, pero entonces vemos que tenemos decenas de proyectos iniciados y hacerlo manualmente para cada uno de ellos es lento y tedioso y como preferimos dedicar el tiempo a tareas más provechosas o estimulantes buscamos la forma de hacerlo de forma automatizada.

Es entonces cuando a nuestro rescate viene una utilidad que podemos encontrar en las diferentes distribuciones Linux, el programa find. Pero estarás pensando, en Windows no tenemos los comandos de Linux, y esto es verdad salvo que hayas instalado git para hacer control de versiones para tu código. Cuando instalas git tienes la opción de instalar bash también y es entonces cuando se instala find y otros comandos propios de Linux en nuestro Windows.

Ya casi estamos llegando al final, pero quisiera mencionar algo antes de mostrarte la línea de comando que hace la magia de borrar todo, y es que va a borrar todas las carpetas node_modules a partir de donde ejecutes el comando. Tendrás que tener bien claro que es esto lo que quieres hacer, borrar todos los node_modules y hacerlo exactamente en el directorio deseado de donde quieres que parta el borrado de todos los node_modules. Si quieres que borre solo algunas carpetas node_modules pero no todas tendrás que adecuar lo que aquí se explica a tu caso particular o quizás usar lo que al final de todo este texto te mostraré también.

Es conveniente también que antes de copiar y pegar un comando en un terminal trates de entender que es lo que el comando hace realmente. Es algo que ya sabes porque o eres un usuario avanzado o un profesional y conoces de los riesgos de copiar, pegar y ejecutar comandos a ciegas, pero no hay daño en recordarlo por si acaso.

Para terminar aquí tienes las instrucciones. Ejecutaremos el comando en la carpeta raíz donde se alojan los proyectos que contienen los directorios node_modules que queramos borrar. Todos los node_modules que penden de ese directorio serán borrados definitivamente. Abrimos un terminal de bash, que como comentamos antes deberás haber instalado con con git y ahí ejecutamos:
```
find . -name 'node_modules' -type d -prune -exec rm -rf '{}' +
```
Y ya no tienes que hacer nada más. Unos segundos después no habrá node_modules bajo ese directorio.

Si te preguntas que hace el comando, simplemente, lo que hace es que a partir del directorio donde estamos ( . ) ejecuta el comando rm -rf '{}' (con -exec ) tantas veces como se encuentra un fichero de tipo directorio ( -type d ) y con nombre node_modules ( -name ‘node_modules’ ) sustituyendo ‘{}’ por la ruta al fichero encontrado. La opción prune hace que no se entre en el directorio node_modules encontrado para seguir buscando a dentro de él. Es decir como vamos a borrar el node_modules con su contenido no tiene sentido buscar también dentro del node_modules que va a ser borrado.

Bueno, esto es todo. Espero que todo esto te solucione algún problema y haya servido también para conocer el comando find que es una utilidad muy potente y adecuada para resolver múltiples problemas con ficheros.

Para terminar, en el caso de que todo esto no te convenza mucho échale un ojo a npkill que tiene una línea de comando como :
```
npx npkill
```
y mediante un sencillo menú te permite seleccionar los proyectos de los que quieres que se borre el node_modules.
2022-05-09

nireleku

Si quieres aprender, enseña!

Twenty Twenty-Five

Diseñado con WordPress