Saltar al contenido
GoTool English

Para desarrollo, QA, webs y servidores

GoTool: la herramienta que entiende y protege tu proyecto.

GoTool lee tu proyecto entero —PHP, TypeScript, JavaScript, Go, SQL y lo de alrededor—, lo dibuja, lo prueba y te dice lo que va a fallar antes de subirlo. Y vigila su seguridad, en tu equipo y en el servidor: tu WordPress, tus contenedores, la máquina. Sin tocar tu código.

Pídenos una demo

Un binario de unos 20 MB para Mac, Windows y Ubuntu, sin nada que instalar al lado · versión 0.49.1

El dibujo de una aplicación Ionic: sus rutas a la derecha y, a la izquierda, los módulos y pantallas que las pintan, con el guard que va antes.

Qué es

Un programa que se lee tu proyecto como lo haría alguien que acaba de llegar —qué rutas tiene, qué pantallas, qué servicios, qué tablas y quién llama a quién— y como lo miraría quien quiere entrar: qué se ha cambiado sin que nadie lo sepa y qué está abierto. No es un editor más ni sustituye a tu CI: es lo que pasa entre los dos, y lo que pasa después.

En tu ordenador

gotool abre el IDE del proyecto: el dibujo, el código, los casos de uso, las pruebas, git y una terminal, también la de tus servidores, dentro de GoTool. Su 🛡 junta toda su seguridad: tu código, su configuración, tus librerías, tu Docker y tu WordPress. Y le contesta a Claude Code lo que pregunte del proyecto (gotool mcp).

En el servidor de pruebas

gotool servidor vigila los proyectos y sus webs, sus WordPress, sus contenedores y la máquina donde corren. Abre los tickets solo cuando algo falla o cambia sin que nadie lo diga, y los reparte entre el equipo. Varios proyectos y varias personas, cada una con su acceso.

1 · Entender y probar

Qué lenguajes lee

Lee el código sin ejecutarlo y sin instalar nada en el proyecto. Lo que saca lo guarda fuera de él.

PHP

Clases, funciones y lo que llama cada una. Symfony: rutas con #[Route], comandos, servicios, Doctrine. composer.json, su lock y vendor/.

TypeScript y JavaScript

React, Angular e Ionic (rutas, módulos, guards, componentes, servicios y sus llamadas a la API), Node y Capacitor. package.json, tsconfig y node_modules/.

Go

Paquetes, tipos, métodos e interfaces, y quién las cumple. Las rutas de net/http, chi, gin, echo y fiber. go.mod y go.sum.

SQL y bases de datos

Las tablas que nombra el código y, si le das acceso, la base de datos de verdad: MySQL, PostgreSQL o Supabase, siempre en sólo lectura.

Lo de alrededor

Los scripts de sh, el Dockerfile, compose, GitHub Actions y los .env (con las claves tapadas): quién llama a quién y qué variable usa cada fichero.

Y usa tus herramientas

Pruebas: vitest, jest, mocha, playwright, phpunit, pest, go test y ng test. Calidad: phpstan, psalm, phpmd, phpcs, eslint, tsc, go vet, staticcheck y golangci-lint. Las que ya tenga el proyecto: no instala ninguna.

Qué hace para entenderlo y probarlo

Todo desde el mismo sitio. Lo que ejecuta (pruebas, casos de uso, calidad) es lo que el proyecto ya tiene; lo demás, sólo lo lee.

  1. Dibuja la aplicación

    Por dónde se entra (rutas, comandos, tareas), qué se ve y qué servicios y tablas hay detrás. A la izquierda lo que usa cada cosa; a la derecha, quién la usa. Doble clic y estás en su código.

  2. Casos de uso, línea a línea

    Ejecuta una función con los datos que le des y enseña, al lado de cada línea, el valor de cada variable y por dónde ha pasado. En PHP, JavaScript/TypeScript y Go, con dobles para lo de fuera (la base de datos, una API).

  3. Pruebas con cobertura

    Pasa las pruebas con la herramienta del proyecto, fichero a fichero, y guarda por dónde pasa cada una: sabes qué prueba toca qué línea y qué se queda sin probar.

  4. El plano: cómo tiene que ser

    Lo que dicen los ficheros de configuración contra lo que hay: la carpeta que falta, la plantilla que no existe, el paquete que no está. Con el porqué y la línea.

  5. Calidad y dependencias

    Si cada fichero pasa o no: errores de sus herramientas, complejidad, cobertura. Lo pedido, lo instalado, lo que tiene versión nueva y los fallos conocidos de cada librería (OSV).

  6. La base de datos, sin miedo

    La lee en sólo lectura, la guarda en DBML y la compara con el contrato o con una foto anterior. Dice qué tabla o columna usa el código y no existe.

  7. Antes de subir

    gotool comprobar dice si un cambio puede subir: pruebas, calidad, dependencias, el plano y la seguridad. gotool push lo comprueba, pasa los casos de uso y, si todo sale bien, hace tu mismo git push; después sigue GitHub Actions paso a paso.

  8. Tickets que se abren solos

    En el servidor de pruebas: la prueba que falla, el error del registro, el fichero cambiado a mano, la web que deja de contestar. Con su fichero y su línea; la extensión de Chrome y la de VS Code los llevan a donde trabajas.

  9. Con Claude

    Claude Code pregunta a GoTool lo que necesita del proyecto. Y gotool reparar pide a Claude el arreglo de un ticket en una copia aparte: pasa las pruebas y te deja el parche y el porqué. Tu código no cambia.

2 · Vigilar la seguridad

¿Lo han tocado ya? ¿Lo van a tocar?

Las dos preguntas que GoTool se hace de cada WordPress, de cada contenedor y de cada máquina. La primera es si ya ha entrado alguien; la segunda, si la seguridad está tan floja que es cuestión de tiempo. Cada respuesta, con de dónde sale y qué hacer.

Comprometido: ya ha entrado alguien

  • El núcleo de WordPress, sus plugins y sus temas, comparados con lo publicado en wordpress.org: un fichero distinto o código de más.
  • PHP en uploads/, mu-plugins nuevos, código de puerta trasera, y administradores nuevos o scripts metidos en las entradas (con su base de datos, sólo en lectura).
  • Código nuevo dentro de un contenedor respecto a su imagen: un .php, un .sh, un programa que no estaba.
  • En la máquina: usuarios, keys, arranques o puertos nuevos, procesos desde /tmp, mineros, y conexiones que parecen un shell inverso.

Expuesto: es cuestión de tiempo

  • Fallos conocidos del núcleo, de cada plugin y de cada tema, con «arreglado en»; plugins retirados o abandonados; WordPress sin actualizar.
  • El modo depuración encendido (WP_DEBUG, APP_DEBUG, Django, Flask, Express), claves de ejemplo o en el código, CORS abierto.
  • Contenedores como root, --privileged, con el socket de Docker dentro o sin límites; imágenes :latest.
  • Lo que se ve desde fuera: la lista de usuarios, xmlrpc.php, debug.log, copias de wp-config.php, .git; cabeceras, https y TLS viejos.

Dónde mira

Tu WordPress

En el servidor, cada 15 minutos, y en tu equipo al abrir el 🛡 del proyecto. Las huellas oficiales de wordpress.org y los fallos de wpvulnerability.net, guardados para no depender de que contesten. También Bedrock.

Tus contenedores

Docker y Podman, por un intermediario de sólo lectura: cómo corre cada uno y lo que ha cambiado dentro. El Dockerfile y el compose, con la guía de contenedores; y las imágenes con trivy o grype si los tienes.

La máquina

Puertos, cortafuegos, usuarios, keys, sudo, lo que arranca solo, el sistema al día y la escalada de privilegios. La primera vez, una foto para revisar; desde ahí, cada cambio es ticket. Cada hallazgo con su CWE y su técnica de MITRE ATT&CK.

A quién llama cada proceso

El centinela aprende siete días lo normal de cada proceso y cada contenedor. Después, un destino nuevo es ticket; un shell o una herramienta de red que llama fuera, los puertos de minería o Tor, siempre alto. En WordPress, qué plugin hace cada llamada.

Tu código y su configuración

SQL montado a mano, XSS, el certificado sin comprobar, secretos en el código, con su CWE y su categoría OWASP. Y lo que dice cada proyecto de sí mismo: PHP, Symfony, Laravel, Node, Next, Django y Flask, cada regla con su fuente.

Lo que instalas

gotool npm ci y gotool composer install bajan las librerías en una carpeta aparte y sin ejecutar nada; miran malware, fallos conocidos y lo nuevo de cada versión, y sólo entonces pasan al proyecto.

Lo mismo en tu equipo que en el servidor: casi todos montan su Docker con su WordPress, lo prueban y lo suben. Mejor saberlo antes.

Y con lo que encuentra

Una lista de fallos no arregla nada. GoTool la pone donde se ve, dice de quién es cada uno y comprueba que de verdad se ha arreglado.

  1. Lo grave, a la vista

    En Inicio, cuántos fallos graves tiene cada proyecto, de tus servidores y de tu equipo. En la pestaña 🛡 Lo grave, la lista entera; en el 🛡 de cada proyecto, todo lo suyo.

  2. Cada fallo, con su estado

    Pendiente, hecho o finalizado. Quien lo arregla dice «hecho» y GoTool lo comprueba en su siguiente vuelta: si sigue ahí, vuelve a pendiente. Lo que es de esperar se cierra con su porqué.

  3. Con tu Jira

    Si usáis Jira Cloud, un fallo se crea como ticket desde el 🛡, sin claves ni IPs. Cuando Jira lo da por terminado, GoTool lo comprueba como siempre.

  4. La puerta

    gotool comprobar y gotool push paran por un secreto que vas a subir, un WordPress tocado, código nuevo en un contenedor o el modo depuración encendido.

La pestaña 🛡 Lo grave: lo de tus servidores y lo de tu equipo, de todos tus proyectos.
La pestaña 🛡 Lo grave: lo de tus servidores y lo de tu equipo, de todos tus proyectos.

Para quién es

Entre escribir el código y que el CI/CD lo pase hay un hueco: entenderlo, probarlo y saber qué se rompe. Y después de subirlo hay otro: saber si alguien lo ha tocado. Los dos los llenan hoy personas a mano. GoTool se los da hechos.

Para QA

  • Ves la aplicación entera sin leer código: rutas, pantallas, servicios y tablas, en un dibujo.
  • Un caso de uso enseña qué ha pasado línea a línea, con los valores. Se acabó el «en mi máquina funciona».
  • Los tickets se abren solos en el servidor de pruebas, con su fichero y su línea, y se reparten.
  • Sabes qué prueba cubre qué y qué se queda sin cubrir antes de decir que algo está probado.

Para desarrolladores

  • Entiendes en minutos un proyecto que no es tuyo: por dónde se entra y qué toca cada cosa.
  • Pruebas una función con unos datos sin levantar la base de datos ni la API: GoTool hace los dobles.
  • Antes del push sabes qué se rompe: pruebas, calidad, dependencias con fallos conocidos y el plano.
  • Claude Code le pregunta a GoTool por el proyecto en vez de leerse los ficheros uno a uno.

Para quien lleva webs con WordPress

  • Sabes si a cada WordPress lo han tocado ya: el núcleo, los plugins y los temas contra lo publicado.
  • Ves qué plugin tiene fallos conocidos y en qué versión se arregla, antes de que lo encuentre otro.
  • Lo pruebas en tu Docker antes de subirlo, con las mismas reglas que en el servidor.
  • Sabes qué plugin llama a dónde: una máquina nueva para un plugin es un aviso.

Para quien lleva los servidores

  • La máquina revisada cada 15 minutos: lo que ha cambiado desde la foto, con su porqué si es de esperar.
  • Los contenedores que corren, cómo lo hacen y lo que ha aparecido dentro.
  • A quién llama cada proceso, y aviso cuando llama a donde nunca había llamado.
  • Root para leer, no para cambiar: sin red, el disco en sólo lectura y sólo las capacidades que necesita.

Y todos miran lo mismo: el mismo dibujo, el mismo caso, el mismo fallo con su estado. Quien lo encuentra dice «está aquí»; quien lo arregla lo abre, lo ve y dice «hecho».

Fotos de la aplicación

Hechas con proyectos de ejemplo: una tienda en Angular/Ionic, otra en Go y otra en PHP, y un WordPress de prueba tocado a propósito. Pulsa una para verla en grande.

El dibujo de una aplicación Ionic: sus rutas a la derecha y, a la izquierda, los módulos y pantallas que las pintan, con el guard que va antes.
El dibujo de una aplicación Ionic: sus rutas a la derecha y, a la izquierda, los módulos y pantallas que las pintan, con el guard que va antes.
Un caso de uso en Go, línea a línea: el valor de cada variable al lado de su línea y por dónde ha pasado.
Un caso de uso en Go, línea a línea: el valor de cada variable al lado de su línea y por dónde ha pasado.
Las pruebas de un proyecto en Go con go test: cuántas pasan y por dónde pasa cada una.
Las pruebas de un proyecto en Go con go test: cuántas pasan y por dónde pasa cada una.
El plano de un proyecto Ionic: lo que dicen angular.json, capacitor.config.ts y los tsconfig, contra lo que hay.
El plano de un proyecto Ionic: lo que dicen angular.json, capacitor.config.ts y los tsconfig, contra lo que hay.
Un servicio de Angular: a la izquierda, las llamadas a la API que hace; a la derecha, las pantallas que lo usan.
Un servicio de Angular: a la izquierda, las llamadas a la API que hace; a la derecha, las pantallas que lo usan.
Los tickets del servidor de pruebas, de varios proyectos: los abre GoTool solo, con su fichero y su línea.
Los tickets del servidor de pruebas, de varios proyectos: los abre GoTool solo, con su fichero y su línea.
Inicio: tus proyectos y, a la derecha, cuántos fallos graves tiene cada uno.
Inicio: tus proyectos y, a la derecha, cuántos fallos graves tiene cada uno.
El 🛡 de un proyecto con WordPress: todo lo suyo en una lista y, a la derecha, cada fallo con su historia y su estado.
El 🛡 de un proyecto con WordPress: todo lo suyo en una lista y, a la derecha, cada fallo con su historia y su estado.
La pestaña 🛡 Lo grave: lo de tus servidores y lo de tu equipo, de todos tus proyectos.
La pestaña 🛡 Lo grave: lo de tus servidores y lo de tu equipo, de todos tus proyectos.

Ninguna enseña código de nadie: son proyectos hechos para probar GoTool.

Lo que GoTool no hace nunca

  • No cambia tu código. Sólo guarda lo que tú escribes en su editor; lo suyo (el mapa, las pruebas, las fotos de la base de datos) va a su carpeta, fuera del proyecto.
  • No instala nada en el proyecto. Usa las herramientas que ya tiene.
  • No escribe en tu base de datos. La lee en sólo lectura, también la de tu WordPress (sin contraseñas ni correos).
  • No hace commit ni push por su cuenta. Sólo cuando tú se lo pides.
  • No enseña tus claves. Los .env y las keys salen tapadas.
  • No cambia tus servidores. La revisión de la máquina y el centinela son root para leer, no para cambiar: lo que ven lo dicen.

Cómo se prueba en 10 minutos

Con un proyecto tuyo de prueba, en tu ordenador. No hace falta servidor.

  1. min 0–1

    Pídenos GoTool

    Escríbenos abajo y te mandamos el de tu sistema (Mac, Windows o Ubuntu) con su SHA256. Es un fichero: no hay instalador.

  2. min 1–2

    Ábrelo con una carpeta

    Doble clic (o gotool en la terminal) y elige la carpeta del proyecto. Antes de nada te enseña su vistazo: qué hay, cuántas líneas y qué parece. Sólo lee.

  3. min 2–4

    Mira el dibujo

    Pulsa «Comenzar proyecto»: lo lee entero y lo dibuja. Sube de nivel para ver más y haz doble clic en cualquier caja para ir a su código.

  4. min 4–6

    Pasa las pruebas

    En 🧪, «pasarlas»: usa la herramienta del proyecto y te dice cuáles pasan, cuáles no y por dónde pasa cada una.

  5. min 6–9

    Un caso de uso

    Abre un servicio, pestaña «Casos de uso», dale unos datos y ▶. Cada línea con sus valores; lo de fuera lo dobla GoTool.

  6. min 9–10

    El 🛡 y antes de subir

    Abre el 🛡 del proyecto: su seguridad, con cada fallo y su estado. Y gotool comprobar: lo que pararía un push y lo que sólo avisa.

Con un proyecto de prueba o una copia, nunca contra producción: GoTool no cambia tu código, pero las pruebas y los casos de uso ejecutan el tuyo de verdad.

Contacto

¿Quieres probarlo, tienes un equipo, unos WordPress o unos servidores que vigilar, o una pregunta? Escríbenos y te contestamos desde info@gotool.run.

Gracias: lo hemos recibido. Te contestamos desde info@gotool.run.

Sólo usamos tus datos para contestarte. Esta web no los guarda ni se los da a nadie.