Neo

Transforme qualquer aplicação web em uma API. Sem API oficial necessária. Sem automação de navegador.

Neo é uma extensão do Chrome que captura passivamente toda chamada de API que seu navegador faz, aprende os padrões e permite que IA (ou você) as reproduza diretamente.

O Problema

Agentes de IA que operam aplicações web hoje têm duas opções, ambas ruins:

Abordagem	Problema
APIs oficiais	A maioria dos SaaS não tem uma, ou expõe apenas 10% dos recursos
Automação de navegador	Screenshot → OCR → clique. Lento, frágil, quebra a cada mudança de UI

Neo é o terceiro caminho. Toda aplicação web já possui uma API interna completa — o frontend a chama toda vez que você clica em algo. Neo captura essas chamadas e as torna reproduzíveis.

v2: Agora com automação de UI. Neo v2 adiciona uma camada de UI baseada em árvore de acessibilidade — snapshot, click, fill, type, press, hover, scroll, select, screenshot, get, wait. Quando uma API existe, use-a diretamente. Quando não existe, Neo pode conduzir a UI através da mesma CLI. Uma ferramenta, ambas as camadas.

Como Funciona

Navegue normalmente → Neo grava todo o tráfego de API → Esquema gerado automaticamente → IA reproduz APIs diretamente
                                                                      → Ou conduz UI via árvore de acessibilidade

1. Captura (sempre ativa)

A extensão do Chrome intercepta todo fetch() e XMLHttpRequest — URLs, cabeçalhos, corpos de requisição/resposta, tempo, até mesmo qual elemento DOM acionou a chamada.

2. Aprenda

Execute neo-schema em um domínio para gerar automaticamente seu mapa de API: endpoints, cabeçalhos de autenticação necessários, parâmetros de consulta, estrutura de resposta, códigos de erro.

3. Execute

Execute chamadas de API dentro do contexto da aba do navegador via Chrome DevTools Protocol. Cookies, tokens CSRF, autenticação de sessão — tudo herdado automaticamente. Sem necessidade de gerenciamento de tokens.

Navegadores Suportados

Navegador	Tipo	Melhor para
Chrome / Chromium	Navegador completo	Captura de API + automação de UI (padrão)
Lightpanda	Headless (Zig)	Agentes de IA, scraping — 11x mais rápido, 9x menos memória

Início Rápido

git clone https://github.com/4ier/neo.git
cd neo && npm install && npm run build
npm link  # torna `neo` disponível globalmente

Carregue a extensão:

Abra chrome://extensions
Ative o "Modo do desenvolvedor"
Clique em "Carregar sem compactação" → selecione extension/dist/
Navegue em qualquer site — Neo começa a capturar imediatamente

Lightpanda (headless, sem necessidade de extensão)

# 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
# Em ~/.neo/config.json:
# { "chromePath": "/usr/local/bin/lightpanda", "browserType": "lightpanda", "cdpPort": 9222 }

neo start    # inicia servidor CDP do Lightpanda
neo connect  # anexa a ele
neo open https://example.com
neo snapshot # árvore de acessibilidade completa

Ferramentas CLI

Todos os comandos passam por uma CLI única: neo <comando>.

Requer um navegador com CDP (Chrome DevTools Protocol) habilitado.

# --- Conexão e Sessões ---
neo connect [port]                          # Conecta ao CDP, salva sessão
neo connect --electron <app-name>           # Descobre automaticamente a porta CDP de um app Electron
neo launch <app> [--port N]                 # Inicia app Electron com CDP habilitado
neo discover                                # Encontra endpoints CDP alcançáveis no localhost
neo sessions                                # Lista sessões salvas
neo tab                                     # Lista alvos CDP na sessão ativa
neo tab <index> | neo tab --url <pattern>   # Alterna alvo da aba ativa
neo inject [--persist] [--tab pattern]      # Injeta script de captura Neo no alvo

# --- Captura e Tráfego ---
neo status                                  # Visão geral dos dados capturados
neo capture summary                         # Visão geral rápida
neo capture list github.com --limit 10      # Mostra IDs para reprodução/detalhes
neo capture list --since 1h                 # Filtrado por tempo
neo capture domains
neo capture search "CreateTweet" --method POST
neo capture watch x.com                     # Acompanhamento ao vivo (como tail -f)
neo capture stats x.com                     # Detalhamento por método/status/tempo
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]            # Deduplicação inteligente

# --- Reprodução e Execução de API ---
neo replay <capture-id> --tab x.com         # Reproduz uma chamada capturada
neo exec <url> --method POST --body '{...}' --tab example.com --auto-headers
neo api x.com HomeTimeline                  # Chamada inteligente (consulta de esquema + autenticação automática)

# --- Esquema e Análise ---
neo schema generate x.com                   # Gera a partir de capturas
neo schema generate --all                   # Lote para todos os domínios
neo schema show x.com [--json]
neo schema openapi x.com                    # Exporta especificação OpenAPI 3.0
neo schema diff x.com                       # Mudanças em relação à versão anterior
neo schema coverage                         # Domínios com/sem esquemas
neo label x.com [--dry-run]                 # Rótulos semânticos de endpoints
neo flows x.com [--window 5000]             # Padrões de sequência de chamadas de API
neo deps x.com [--min-confidence 1]         # Dependências de dados resposta→requisição
neo workflow discover|show|run <name>       # Descoberta e reprodução de fluxos de múltiplas etapas
neo suggest x.com                           # Análise de capacidades por IA
neo export-skill x.com                      # Gera SKILL.md pronto para agente

# --- Automação de UI (v2) ---
neo snapshot [-i] [-C] [--json]             # Árvore de acessibilidade com mapeamento @ref
neo click @ref [--new-tab]                  # Clica no elemento pelo @ref
neo fill @ref "text"                        # Limpa + preenche input
neo type @ref "text"                        # Acrescenta texto ao input
neo press <key>                             # Tecla do teclado (suporta Ctrl+a, Enter, etc.)
neo hover @ref                              # Passa o mouse sobre o elemento
neo scroll <dir> [px] [--selector css]      # Rola por direção
neo select @ref "value"                     # Define valor de dropdown
neo screenshot [path] [--full] [--annotate] # Captura screenshot
neo get text @ref | neo get url | neo get title  # Extrai informações
neo wait @ref | neo wait --load networkidle | neo wait <ms>  # Aguarda elemento/carregamento/tempo

# --- Interação com Página ---
neo read github.com                         # Extrai texto legível
neo eval "document.title" --tab github.com  # Executa JS na página
neo open https://example.com                # Abre URL

# --- Mock e Bridge ---
neo mock x.com [--port 8080 --latency 200]  # Servidor mock a partir do esquema
neo bridge [--json] [--interactive]          # Fluxo de captura em tempo real via WebSocket

# --- Diagnóstico ---
neo doctor                                  # Verifica Chrome, extensão, esquemas
neo reload                                  # Recarrega extensão a partir da CLI
neo tabs [filter]                           # Lista abas abertas do Chrome

Sessões e Suporte a Múltiplos Aplicativos

Neo não é só para Chrome. Qualquer aplicativo com suporte a CDP funciona — incluindo aplicativos Electron:

# Iniciar VS Code com CDP e conectar
neo launch code --port 9230
neo snapshot                # Ver árvore de acessibilidade do VS Code
neo click @14               # Clicar em um item de menu

# Ou conectar a um app Electron já em execução
neo connect --electron slack

# Injetar script de captura do Neo em qualquer alvo CDP
neo inject --persist        # Sobrevive à navegação da página
neo inject --tab slack      # Mirar em aba específica

As sessões são salvas automaticamente. Alterne entre elas com --session:

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

Automação de UI (v2)

Neo v2 adiciona uma camada completa de interação de UI construída sobre a árvore de acessibilidade — sem screenshots, sem coordenadas, sem correspondência de pixels:

# 1. Tire um snapshot — cada elemento interativo recebe um @ref
neo snapshot
#  @1  button "Sign in"
#  @2  textbox "Search"
#  @3  link "Pricing"

# 2. Interaja usando @ref
neo click @1
neo fill @2 "AI agents"
neo press Enter
neo screenshot results.png --full

Isso dá aos agentes de IA uma maneira rápida e semântica de interagir com qualquer UI. Combine com captura de API para uma abordagem de canal duplo: use APIs quando elas existirem, recorra à UI quando não existirem.

O bridge cria um canal WebSocket persistente entre a extensão e a CLI. A extensão se conecta automaticamente a ws://127.0.0.1:9234 e transmite cada captura em tempo real. No modo interativo, você pode consultar a extensão diretamente: ping, status, capture.count, capture.list, capture.domains, capture.search, capture.clear.

Arquitetura

┌─────────────────────────────────────┐
│  Chrome / Electron App (CDP)         │
│                                      │
│  inject/interceptor.ts               │
│    ├─ Monkey-patches fetch & XHR     │
│    ├─ Intercepts WebSocket/SSE       │
│    ├─ Tracks DOM triggers (click →   │
│    │   API correlation)              │
│    └─ Records full request/response  │
│                                      │
│  content/index.ts                    │
│    └─ Bridges page ↔ extension       │
│                                      │
│  background/index.ts                 │
│    ├─ Persists to IndexedDB (Dexie)  │
│    ├─ Per-domain cap (500 entries)   │
│    └─ WebSocket Bridge client        │
│                                      │
└──────────────┬──────────────────────┘
               │ Chrome DevTools Protocol
┌──────────────┴──────────────────────┐
│  CLI: neo (Node.js)                  │
│                                      │
│  Layer 1: API Capture & Replay       │
│  ├─ neo capture → traffic management │
│  ├─ neo schema  → API discovery      │
│  ├─ neo exec    → execute in browser │
│  ├─ neo api     → smart schema call  │
│  ├─ neo replay  → re-run captured    │
│  └─ neo flows/deps → pattern analysis│
│                                      │
│  Layer 2: UI Automation (v2)         │
│  ├─ neo snapshot → a11y tree + @refs │
│  ├─ neo click/fill/type/press/hover  │
│  ├─ neo scroll/select/screenshot     │
│  └─ neo get/wait                     │
│                                      │
│  Session Management                  │
│  ├─ neo connect/launch/discover      │
│  ├─ neo tab → target switching       │
│  └─ neo inject → script injection    │
│                                      │
└──────────────┬──────────────────────┘
               │
┌──────────────┴──────────────────────┐
│  AI Agent (OpenClaw / any LLM)       │
│  ├─ API-first: schema → exec/api     │
│  ├─ UI fallback: snapshot → click    │
│  └─ Dual-channel automation          │
└──────────────────────────────────────┘

Demonstração Real

Publicar um tweet via API capturada

# 1. Navegue pelo X normalmente — Neo captura mutações GraphQL
neo schema show api.x.com

# 2. Encontre o endpoint CreateTweet
neo capture search "CreateTweet" --method POST

# 3. Reproduza com a autenticação original (cookies herdados automaticamente)
neo replay abc123 --tab x.com

# 4. Ou crie uma nova chamada com cabeçalhos de autenticação detectados automaticamente
neo exec "https://x.com/i/api/graphql/.../CreateTweet" \
  --method POST --auto-headers \
  --body '{"variables":{"tweet_text":"Hello from Neo!"},...}'

Entender o que um botão faz

O rastreamento de gatilhos do Neo mapeia interações de UI para chamadas de API:

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

Monitorar tráfego de API ao vivo

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]

Armazenamento

Limite por domínio: máximo de 500 capturas por domínio, as mais antigas são limpas automaticamente
Truncamento de corpo: corpos de resposta limitados a 100KB
Localização: IndexedDB do Chrome (banco de dados neo-capture-v01)
Esquemas: Exportáveis como arquivos JSON para persistência entre dispositivos

Filtragem Inteligente

O interceptor ignora ruídos automaticamente:

Ativos estáticos (imagens, fontes, CSS, bundles JS)
Analytics/rastreamento (Google Analytics, Meta Pixel, Sentry, etc.)
Internos do navegador (chrome-extension://, data:, blob:)
Limitação de taxa: máximo de 3 capturas por padrão de URL por minuto (evita inchaço por polling de endpoint)

Segurança e Privacidade

Neo é executado inteiramente localmente — sem servidores externos, sem telemetria, nenhum dado sai da sua máquina.

O que o Neo captura: Toda chamada fetch/XHR/WebSocket que seu navegador faz em todos os sites. Isso é poderoso, mas invasivo por design.

Redação de cabeçalhos de autenticação (v1.1.0+): Os valores dos cabeçalhos de autenticação (tokens Bearer, tokens CSRF, cookies, IDs de sessão) são redigidos no momento da captura antes do armazenamento. O IndexedDB armazena apenas os nomes dos cabeçalhos, não os valores. Quando --auto-headers executa uma chamada de API, ele obtém cabeçalhos de autenticação em tempo real do navegador via CDP — nunca reproduz credenciais armazenadas.

O que você deve saber:

Recomendações:

Revise os domínios capturados periodicamente: neo capture domains
Remova capturas sensíveis: neo capture clear banksite.com
Não instale o Neo em máquinas compartilhadas onde outras pessoas tenham acesso local
A porta CDP (9222) não deve ser exposta além do localhost

Neo é uma ferramenta de desenvolvedor que troca superfície de privacidade por capacidade. Use-a com conhecimento.

Pilha Tecnológica

TypeScript, Vite (build multi-entry)
Chrome Manifest V3
Dexie.js (wrapper IndexedDB)
Chrome DevTools Protocol para comunicação CLI ↔ navegador
Nenhum servidor backend, nenhuma dependência externa em tempo de execução

Roadmap

Licença

MIT

Escopo de captura	`<all_urls>` — Neo vê tráfego em todos os sites, incluindo bancos, e-mail, portais médicos
Script de conteúdo	Executa no mundo `MAIN` (compartilha contexto JS com as páginas) para interceptar fetch/XHR
Porta CDP	A CLI requer Chrome na porta 9222 — qualquer processo local pode se conectar a essa porta
Corpos de resposta	Armazenados no IndexedDB (truncados para 100KB) — podem conter dados pessoais de respostas de API
Arquivos de esquema	Armazenam apenas estrutura de endpoint (caminhos, nomes de cabeçalhos, formas de resposta) — nenhuma credencial ou dado do usuário
Exportação	`neo capture export` redige autenticação por padrão; `--include-auth` requer aceitação explícita

Mais Populares

neo

Neo