Neo

Convierte cualquier aplicación web en una API. Sin API oficial. Sin automatización del navegador.

Neo es una extensión de Chrome que captura pasivamente cada llamada API que realiza tu navegador, aprende los patrones y permite que la IA (o tú) las reproduzcan directamente.

El Problema

Los agentes de IA que operan aplicaciones web hoy tienen dos opciones, ambas malas:

Enfoque	Problema
APIs oficiales	La mayoría de SaaS no tiene una, o solo expone el 10% de las funciones
Automatización del navegador	Captura de pantalla → OCR → clic. Lento, frágil, se rompe con cada cambio de interfaz

Neo es la tercera vía. Cada aplicación web ya tiene una API interna completa — el frontend la llama cada vez que haces clic en algo. Neo captura esas llamadas y las hace reproducibles.

v2: Ahora con automatización de IU. Neo v2 añade una capa de interfaz de usuario basada en el árbol de accesibilidad — snapshot, click, fill, type, press, hover, scroll, select, screenshot, get, wait. Cuando existe una API, úsala directamente. Cuando no, Neo puede manejar la IU a través del mismo CLI. Una herramienta, ambas capas.

Cómo Funciona

Navega normalmente → Neo registra todo el tráfico API → Esquema generado automáticamente → IA reproduce APIs directamente
                                                                      → O maneja la IU mediante el árbol de accesibilidad

1. Captura (siempre activa)

La extensión de Chrome intercepta cada fetch() y XMLHttpRequest — URLs, cabeceras, cuerpos de solicitud/respuesta, tiempos, incluso qué elemento del DOM desencadenó la llamada.

2. Aprende

Ejecuta neo-schema en un dominio para generar automáticamente su mapa de API: endpoints, cabeceras de autenticación requeridas, parámetros de consulta, estructura de respuesta, códigos de error.

3. Ejecuta

Ejecuta llamadas API dentro del contexto de la pestaña del navegador a través del Protocolo de Chrome DevTools. Cookies, tokens CSRF, autenticación de sesión — todo se hereda automáticamente. No se necesita gestión de tokens.

Navegadores Compatibles

Navegador	Tipo	Ideal para
Chrome / Chromium	Navegador completo	Captura API + automatización IU (por defecto)
Lightpanda	Sin cabeza (Zig)	Agentes IA, scraping — 11x más rápido, 9x menos memoria

Inicio Rápido

git clone https://github.com/4ier/neo.git
cd neo && npm install && npm run build
npm link  # hace que `neo` esté disponible globalmente

Carga la extensión:

Abre chrome://extensions
Activa "Modo desarrollador"
Haz clic en "Cargar descomprimida" → selecciona extension/dist/
Navega a cualquier sitio web — Neo comienza a capturar inmediatamente

Lightpanda (sin cabeza, sin necesidad de extensión)

# Instalar Lightpanda
curl -L -o lightpanda https://github.com/lightpanda-io/browser/releases/download/nightly/lightpanda-x86_64-linux
chmod +x lightpanda && sudo mv lightpanda /usr/local/bin/

# Configurar Neo para usar Lightpanda
# En ~/.neo/config.json:
# { "chromePath": "/usr/local/bin/lightpanda", "browserType": "lightpanda", "cdpPort": 9222 }

neo start    # inicia el servidor CDP de Lightpanda
neo connect  # conéctate a él
neo open https://example.com
neo snapshot # árbol de accesibilidad completo

Herramientas CLI

Todos los comandos pasan por un único CLI: neo <comando>.

Requiere un navegador con CDP (Protocolo Chrome DevTools) habilitado.

# --- Conexión y Sesiones ---
neo connect [port]                          # Conectar a CDP, guardar sesión
neo connect --electron <app-name>           # Descubrir automáticamente el puerto CDP de una app Electron
neo launch <app> [--port N]                 # Iniciar app Electron con CDP habilitado
neo discover                                # Encontrar endpoints CDP accesibles en localhost
neo sessions                                # Listar sesiones guardadas
neo tab                                     # Listar objetivos CDP en la sesión activa
neo tab <index> | neo tab --url <pattern>   # Cambiar objetivo de pestaña activa
neo inject [--persist] [--tab pattern]      # Inyectar script de captura de Neo en el objetivo

# --- Captura y Tráfico ---
neo status                                  # Resumen de datos capturados
neo capture summary                         # Visión general rápida
neo capture list github.com --limit 10      # Muestra IDs para reproducción/detalle
neo capture list --since 1h                 # Filtrado por tiempo
neo capture domains
neo capture search "CreateTweet" --method POST
neo capture watch x.com                     # Seguimiento en vivo (como tail -f)
neo capture stats x.com                     # Desglose de método/estado/tiempo
neo capture export x.com --since 2h > x.json
neo capture export x.com --format har > x.har  # HAR 1.2 para Postman/devtools
neo capture import x-captures.json
neo capture prune --older-than 7d
neo capture gc x.com [--dry-run]            # Deduplicación inteligente

# --- Reproducción y Ejecución de API ---
neo replay <capture-id> --tab x.com         # Reproducir una llamada capturada
neo exec <url> --method POST --body '{...}' --tab example.com --auto-headers
neo api x.com HomeTimeline                  # Llamada inteligente (búsqueda en esquema + autenticación automática)

# --- Esquema y Análisis ---
neo schema generate x.com                   # Generar a partir de capturas
neo schema generate --all                   # Procesar por lotes todos los dominios
neo schema show x.com [--json]
neo schema openapi x.com                    # Exportar especificación OpenAPI 3.0
neo schema diff x.com                       # Cambios respecto a versión anterior
neo schema coverage                         # Dominios con/sin esquemas
neo label x.com [--dry-run]                 # Etiquetas semánticas de endpoints
neo flows x.com [--window 5000]             # Patrones de secuencia de llamadas API
neo deps x.com [--min-confidence 1]         # Dependencias de datos respuesta→solicitud
neo workflow discover|show|run <name>       # Descubrimiento y reproducción de flujos multi-paso
neo suggest x.com                           # Análisis de capacidades con IA
neo export-skill x.com                      # Generar archivo SKILL.md listo para agente

# --- Automatización de IU (v2) ---
neo snapshot [-i] [-C] [--json]             # Árbol de accesibilidad con mapeo @ref
neo click @ref [--new-tab]                  # Hacer clic en elemento por @ref
neo fill @ref "texto"                        # Limpiar y rellenar campo de entrada
neo type @ref "texto"                        # Añadir texto a campo de entrada
neo press <tecla>                             # Tecla del teclado (soporta Ctrl+a, Enter, etc.)
neo hover @ref                              # Pasar el ratón sobre elemento
neo scroll <dir> [px] [--selector css]      # Desplazar en dirección
neo select @ref "valor"                     # Establecer valor de menú desplegable
neo screenshot [ruta] [--full] [--annotate] # Tomar captura de pantalla
neo get text @ref | neo get url | neo get title  # Extraer información
neo wait @ref | neo wait --load networkidle | neo wait <ms>  # Esperar elemento/carga/tiempo

# --- Interacción con Página ---
neo read github.com                         # Extraer texto legible
neo eval "document.title" --tab github.com  # Ejecutar JS en la página
neo open https://example.com                # Abrir URL

# --- Simulación y Puente ---
neo mock x.com [--port 8080 --latency 200]  # Servidor simulado a partir del esquema
neo bridge [--json] [--interactive]          # Flujo de captura en WebSocket en tiempo real

# --- Diagnósticos ---
neo doctor                                  # Verificar Chrome, extensión, esquemas
neo reload                                  # Recargar extensión desde CLI
neo tabs [filter]                           # Listar pestañas abiertas de Chrome

Sesiones y Soporte Multi-Aplicación

Neo no es solo para Chrome. Cualquier aplicación con soporte CDP funciona — incluidas las apps Electron:

# Iniciar VS Code con CDP y conectar
neo launch code --port 9230
neo snapshot                # Ver el árbol de accesibilidad de VS Code
neo click @14               # Hacer clic en un elemento del menú

# O conectar a una app Electron ya en ejecución
neo connect --electron slack

# Inyectar script de captura de Neo en cualquier objetivo CDP
neo inject --persist        # Sobrevive a la navegación de página
neo inject --tab slack      # Apuntar a una pestaña específica

Las sesiones se guardan automáticamente. Cambia entre ellas con --session:

neo --session vscode snapshot
neo --session chrome api x.com HomeTimeline

Automatización de IU (v2)

Neo v2 añade una capa completa de interacción con la IU basada en el árbol de accesibilidad — sin capturas de pantalla, sin coordenadas, sin coincidencia de píxeles:

# 1. Tomar una instantánea — cada elemento interactivo obtiene un @ref
neo snapshot
#  @1  button "Iniciar sesión"
#  @2  textbox "Buscar"
#  @3  link "Precios"

# 2. Interactuar por @ref
neo click @1
neo fill @2 "Agentes IA"
neo press Enter
neo screenshot resultados.png --full

Esto proporciona a los agentes de IA una forma rápida y semántica de interactuar con cualquier IU. Combínalo con la captura de API para un enfoque de doble canal: usa APIs cuando existan, recurre a la IU cuando no.

El puente crea un canal WebSocket persistente entre la extensión y el CLI. La extensión se conecta automáticamente a ws://127.0.0.1:9234 y transmite cada captura en tiempo real. En modo interactivo, puedes consultar la extensión directamente: ping, status, capture.count, capture.list, capture.domains, capture.search, capture.clear.

Arquitectura

┌─────────────────────────────────────┐
│  Chrome / Electron App (CDP)         │
│                                      │
│  inject/interceptor.ts               │
│    ├─ Parches de mono para fetch & XHR
│    ├─ Intercepta WebSocket/SSE       │
│    ├─ Rastrea desencadenantes del DOM (clic →
│    │   correlación API)              │
│    └─ Registra solicitud/respuesta completa
│                                      │
│  content/index.ts                    │
│    └─ Puente página ↔ extensión      │
│                                      │
│  background/index.ts                 │
│    ├─ Persiste en IndexedDB (Dexie)  │
│    ├─ Límite por dominio (500 entradas)
│    └─ Cliente puente WebSocket        │
│                                      │
└──────────────┬──────────────────────┘
               │ Protocolo Chrome DevTools
┌──────────────┴──────────────────────┐
│  CLI: neo (Node.js)                  │
│                                      │
│  Capa 1: Captura y Reproducción API  │
│  ├─ neo capture → gestión de tráfico │
│  ├─ neo schema  → descubrimiento API │
│  ├─ neo exec    → ejecutar en navegador│
│  ├─ neo api     → llamada inteligente al esquema│
│  ├─ neo replay  → re-ejecutar capturado│
│  └─ neo flows/deps → análisis de patrones│
│                                      │
│  Capa 2: Automatización de IU (v2)   │
│  ├─ neo snapshot → árbol de accesibilidad + @refs│
│  ├─ neo click/fill/type/press/hover  │
│  ├─ neo scroll/select/screenshot     │
│  └─ neo get/wait                     │
│                                      │
│  Gestión de Sesiones                 │
│  ├─ neo connect/launch/discover      │
│  ├─ neo tab → cambio de objetivo     │
│  └─ neo inject → inyección de script │
│                                      │
└──────────────┬──────────────────────┘
               │
┌──────────────┴──────────────────────┐
│  Agente IA (OpenClaw / cualquier LLM)│
│  ├─ Primero API: schema → exec/api   │
│  ├─ Retroceso IU: snapshot → click   │
│  └─ Automatización de doble canal    │
└──────────────────────────────────────┘

Demostración del Mundo Real

Publicar un tweet mediante API capturada

# 1. Navega por X normalmente — Neo captura mutaciones GraphQL
neo schema show api.x.com

# 2. Encuentra el endpoint CreateTweet
neo capture search "CreateTweet" --method POST

# 3. Reproduce con la autenticación original (las cookies se heredan automáticamente)
neo replay abc123 --tab x.com

# 4. O crea una nueva llamada con cabeceras de autenticación detectadas automáticamente
neo exec "https://x.com/i/api/graphql/.../CreateTweet" \
  --method POST --auto-headers \
  --body '{"variables":{"tweet_text":"¡Hola desde Neo!"},...}'

Entender qué hace un botón

El seguimiento de desencadenantes de Neo mapea las interacciones de IU con las llamadas API:

neo schema show github.com
# La salida incluye:
#   POST /repos/:owner/:repo/star  (3x, 280ms)
#     ← click button.js-social-form "Star" (3x)

Monitorizar en vivo el tráfico API

neo capture watch api.openai.com
# 14:23:01  POST 200 /v1/chat/completions (1230ms)
# 14:23:05  SSE_MSG 200 /v1/chat/completions (0ms) [sse]

Almacenamiento

Límite por dominio: 500 capturas máximo por dominio, las más antiguas se limpian automáticamente
Truncamiento de cuerpo: Cuerpos de respuesta limitados a 100KB
Ubicación: IndexedDB de Chrome (base de datos neo-capture-v01)
Esquemas: Exportables como archivos JSON para persistencia entre dispositivos

Filtrado Inteligente

El interceptor ignora el ruido automáticamente:

Activos estáticos (imágenes, fuentes, CSS, paquetes JS)
Analytics/seguimiento (Google Analytics, Meta Pixel, Sentry, etc.)
Elementos internos del navegador (chrome-extension://, data:, blob:)
Límite de velocidad: Máximo 3 capturas por patrón de URL por minuto (evita la hinchazón de endpoints de sondeo)

Seguridad y Privacidad

Neo se ejecuta completamente local — sin servidores externos, sin telemetría, ningún dato sale de tu máquina.

Lo que captura Neo: Cada llamada fetch/XHR/WebSocket que tu navegador realiza en cada sitio web. Esto es poderoso pero invasivo por diseño.

Ofuscación de cabeceras de autenticación (v1.1.0+): Los valores de las cabeceras de autenticación (tokens Bearer, tokens CSRF, cookies, IDs de sesión) se ofuscan en el momento de la captura antes del almacenamiento. IndexedDB solo almacena los nombres de las cabeceras, no los valores. Cuando --auto-headers ejecuta una llamada API, obtiene las cabeceras de autenticación en vivo del navegador en tiempo real a través de CDP — nunca reproduce credenciales almacenadas.

Lo que debes saber:

Recomendaciones:

Revisa periódicamente los dominios capturados: neo capture domains
Elimina capturas sensibles: neo capture clear banksite.com
No instales Neo en máquinas compartidas donde otros tengan acceso local
El puerto CDP (9222) no debe exponerse más allá de localhost

Neo es una herramienta de desarrollo que intercambia superficie de privacidad por capacidad. Úsala con conocimiento.

Stack Tecnológico

TypeScript, Vite (compilación multi-entrada)
Chrome Manifest V3
Dexie.js (envoltorio de IndexedDB)
Protocolo Chrome DevTools para comunicación CLI ↔ navegador
Sin servidor backend, sin dependencias externas en tiempo de ejecución

Hoja de Ruta

Licencia

MIT

Alcance de captura	`<all_urls>` — Neo ve tráfico en todos los sitios web, incluidos bancos, correo, portales médicos
Script de contenido	Se ejecuta en el mundo `MAIN` (comparte contexto JS con las páginas) para interceptar fetch/XHR
Puerto CDP	El CLI requiere Chrome en el puerto 9222 — cualquier proceso local puede conectarse a este puerto
Cuerpos de respuesta	Almacenados en IndexedDB (truncados a 100KB) — pueden contener datos personales de respuestas API
Archivos de esquema	Almacenan solo la estructura de endpoints (rutas, nombres de cabeceras, formas de respuesta) — sin credenciales ni datos de usuario
Exportación	`neo capture export` ofusca autenticación por defecto; `--include-auth` requiere aceptación explícita

Más Populares

neo

Neo