Neo

Transformez n'importe quelle application web en API. Aucune API officielle nécessaire. Aucune automatisation de navigateur.

Neo est une extension Chrome qui capture passivement chaque appel API effectué par votre navigateur, apprend les modèles, et permet à l'IA (ou à vous) de les rejouer directement.

Le Problème

Les agents IA qui interagissent avec les applications web ont aujourd'hui deux options, toutes deux mauvaises :

Approche	Inconvénient
API officielles	La plupart des SaaS n'en ont pas, ou n'exposent que 10% des fonctionnalités
Automatisation de navigateur	Capture d'écran → OCR → clic. Lent, fragile, casse à chaque changement d'interface

Neo est la troisième voie. Chaque application web possède déjà une API interne complète — le frontend l'appelle à chaque fois que vous cliquez sur quelque chose. Neo capture ces appels et les rend rejouables.

v2 : Maintenant avec automatisation de l'interface. Neo v2 ajoute une couche d'interface basée sur l'arbre d'accessibilité — snapshot, click, fill, type, press, hover, scroll, select, screenshot, get, wait. Quand une API existe, utilisez-la directement. Quand elle n'existe pas, Neo peut piloter l'interface via la même CLI. Un outil, deux couches.

Comment ça marche

Naviguer normalement → Neo enregistre tout le trafic API → Schéma auto-généré → L'IA rejoue les API directement
                                                                                → Ou pilote l'interface via l'arbre a11y

1. Capture (toujours active)

L'extension Chrome intercepte chaque fetch() et XMLHttpRequest — URL, en-têtes, corps de requête/réponse, timing, et même l'élément DOM qui a déclenché l'appel.

2. Apprentissage

Exécutez neo-schema sur un domaine pour générer automatiquement sa carte API : points de terminaison, en-têtes d'authentification requis, paramètres de requête, structure des réponses, codes d'erreur.

3. Exécution

Exécutez des appels API dans le contexte de l'onglet du navigateur via le protocole Chrome DevTools. Cookies, tokens CSRF, authentification de session — tout est hérité automatiquement. Aucune gestion de token nécessaire.

Navigateurs supportés

Navigateur	Type	Idéal pour
Chrome / Chromium	Navigateur complet	Capture API + automatisation de l'interface (par défaut)
Lightpanda	Sans tête (Zig)	Agents IA, scraping — 11x plus rapide, 9x moins de mémoire

Démarrage rapide

git clone https://github.com/4ier/neo.git
cd neo && npm install && npm run build
npm link  # rend `neo` disponible globalement

Chargez l'extension :

Ouvrez chrome://extensions
Activez le "Mode développeur"
Cliquez sur "Charger l'extension non empaquetée" → sélectionnez extension/dist/
Naviguez sur n'importe quel site — Neo commence à capturer immédiatement

Lightpanda (sans tête, aucune extension nécessaire)

# Installer 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/

# Configurer Neo pour utiliser Lightpanda
# Dans ~/.neo/config.json :
# { "chromePath": "/usr/local/bin/lightpanda", "browserType": "lightpanda", "cdpPort": 9222 }

neo start    # lance le serveur CDP de Lightpanda
neo connect  # s'y attacher
neo open https://example.com
neo snapshot # arbre a11y complet

Outils CLI

Toutes les commandes passent par une seule CLI : neo <command>.

Nécessite un navigateur avec CDP (Chrome DevTools Protocol) activé.

# --- Connexion et Sessions ---
neo connect [port]                          # Se connecter au CDP, sauvegarder la session
neo connect --electron <app-name>           # Découvrir automatiquement le port CDP d'une app Electron
neo launch <app> [--port N]                 # Lancer une app Electron avec CDP activé
neo discover                                # Trouver les points de terminaison CDP accessibles sur localhost
neo sessions                                # Lister les sessions sauvegardées
neo tab                                     # Lister les cibles CDP dans la session active
neo tab <index> | neo tab --url <pattern>   # Changer la cible de l'onglet actif
neo inject [--persist] [--tab pattern]      # Injecter le script de capture Neo dans la cible

# --- Capture et Trafic ---
neo status                                  # Aperçu des données capturées
neo capture summary                         # Aperçu rapide
neo capture list github.com --limit 10      # Affiche les IDs pour rejeu/détail
neo capture list --since 1h                 # Filtré par temps
neo capture domains
neo capture search "CreateTweet" --method POST
neo capture watch x.com                     # Suivi en direct (comme tail -f)
neo capture stats x.com                     # Répartition méthode/statut/timing
neo capture export x.com --since 2h > x.json
neo capture export x.com --format har > x.har  # HAR 1.2 pour Postman/devtools
neo capture import x-captures.json
neo capture prune --older-than 7d
neo capture gc x.com [--dry-run]            # Déduplication intelligente

# --- Rejeu et Exécution d'API ---
neo replay <capture-id> --tab x.com         # Rejouer un appel capturé
neo exec <url> --method POST --body '{...}' --tab example.com --auto-headers
neo api x.com HomeTimeline                  # Appel intelligent (recherche de schéma + authentification automatique)

# --- Schéma et Analyse ---
neo schema generate x.com                   # Générer à partir des captures
neo schema generate --all                   # Traiter tous les domaines par lot
neo schema show x.com [--json]
neo schema openapi x.com                    # Exporter la spécification OpenAPI 3.0
neo schema diff x.com                       # Changements par rapport à la version précédente
neo schema coverage                         # Domaines avec/sans schémas
neo label x.com [--dry-run]                 # Étiquettes sémantiques pour les points de terminaison
neo flows x.com [--window 5000]             # Modèles de séquences d'appels API
neo deps x.com [--min-confidence 1]         # Dépendances de données réponse→requête
neo workflow discover|show|run <name>       # Découverte et rejeu de workflows multi-étapes
neo suggest x.com                           # Analyse des capacités par IA
neo export-skill x.com                      # Générer un SKILL.md prêt pour l'agent

# --- Automatisation de l'interface (v2) ---
neo snapshot [-i] [-C] [--json]             # Arbre a11y avec mapping @ref
neo click @ref [--new-tab]                  # Cliquer sur un élément par @ref
neo fill @ref "text"                        # Effacer + remplir un champ
neo type @ref "text"                        # Ajouter du texte à un champ
neo press <key>                             # Touche clavier (supporte Ctrl+a, Entrée, etc.)
neo hover @ref                              # Survoller un élément
neo scroll <dir> [px] [--selector css]      # Défiler par direction
neo select @ref "value"                     # Définir la valeur d'une liste déroulante
neo screenshot [path] [--full] [--annotate] # Prendre une capture d'écran
neo get text @ref | neo get url | neo get title  # Extraire des informations
neo wait @ref | neo wait --load networkidle | neo wait <ms>  # Attendre un élément/chargement/temps

# --- Interaction avec la Page ---
neo read github.com                         # Extraire le texte lisible
neo eval "document.title" --tab github.com  # Exécuter du JS dans la page
neo open https://example.com                # Ouvrir une URL

# --- Simulation et Pont ---
neo mock x.com [--port 8080 --latency 200]  # Serveur de simulation à partir du schéma
neo bridge [--json] [--interactive]          # Flux de capture WebSocket en temps réel

# --- Diagnostic ---
neo doctor                                  # Vérifier Chrome, l'extension, les schémas
neo reload                                  # Recharger l'extension depuis la CLI
neo tabs [filter]                           # Lister les onglets Chrome ouverts

Sessions et Support Multi-App

Neo n'est pas réservé à Chrome. Toute application avec support CDP fonctionne — y compris les applications Electron :

# Lancer VS Code avec CDP et se connecter
neo launch code --port 9230
neo snapshot                # Voir l'arbre d'accessibilité de VS Code
neo click @14               # Cliquer sur un élément de menu

# Ou se connecter à une application Electron déjà en cours d'exécution
neo connect --electron slack

# Injecter le script de capture de Neo dans n'importe quelle cible CDP
neo inject --persist        # Survit à la navigation sur la page
neo inject --tab slack      # Cibler un onglet spécifique

Les sessions sont sauvegardées automatiquement. Passez de l'une à l'autre avec --session :

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

Automatisation de l'interface (v2)

Neo v2 ajoute une couche d'interaction complète basée sur l'arbre d'accessibilité — sans captures d'écran, sans coordonnées, sans correspondance de pixels :

# 1. Prendre un instantané — chaque élément interactif reçoit un @ref
neo snapshot
#  @1  button "Connexion"
#  @2  textbox "Rechercher"
#  @3  link "Tarifs"

# 2. Interagir par @ref
neo click @1
neo fill @2 "Agents IA"
neo press Enter
neo screenshot resultats.png --full

Cela offre aux agents IA un moyen rapide et sémantique d'interagir avec n'importe quelle interface. Combinez avec la capture API pour une approche double canal : utilisez les API quand elles existent, retombez sur l'interface quand elles n'existent pas.

Le pont crée un canal WebSocket persistant entre l'extension et la CLI. L'extension se connecte automatiquement à ws://127.0.0.1:9234 et diffuse chaque capture en temps réel. En mode interactif, vous pouvez interroger l'extension directement : ping, status, capture.count, capture.list, capture.domains, capture.search, capture.clear.

Architecture

┌─────────────────────────────────────┐
│  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          │
└──────────────────────────────────────┘

Démonstration Réelle

Publier un tweet via l'API capturée

# 1. Naviguez sur X normalement — Neo capture les mutations GraphQL
neo schema show api.x.com

# 2. Trouvez le point de terminaison CreateTweet
neo capture search "CreateTweet" --method POST

# 3. Rejouez avec l'authentification d'origine (cookies hérités automatiquement)
neo replay abc123 --tab x.com

# 4. Ou créez un nouvel appel avec les en-têtes d'authentification détectés automatiquement
neo exec "https://x.com/i/api/graphql/.../CreateTweet" \
  --method POST --auto-headers \
  --body '{"variables":{"tweet_text":"Hello from Neo!"},...}'

Comprendre ce que fait un bouton

Le suivi des déclencheurs de Neo associe les interactions de l'interface aux appels API :

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

Surveiller le trafic API en direct

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]

Stockage

Limite par domaine : 500 captures maximum par domaine, les plus anciennes sont automatiquement nettoyées
Troncature du corps : Corps de réponse limité à 100 Ko
Emplacement : IndexedDB de Chrome (base de données neo-capture-v01)
Schémas : Exportables sous forme de fichiers JSON pour une persistance entre appareils

Filtrage Intelligent

L'intercepteur ignore automatiquement le bruit :

Ressources statiques (images, polices, CSS, bundles JS)
Analytics/tracking (Google Analytics, Meta Pixel, Sentry, etc.)
Internes du navigateur (chrome-extension://, data:, blob:)
Limitation de débit : Maximum 3 captures par motif d'URL par minute (empêche l'expansion due aux points de terminaison de sondage)

Sécurité et Confidentialité

Neo fonctionne entièrement localement — aucun serveur externe, aucune télémétrie, aucune donnée ne quitte votre machine.

Ce que Neo capture : Chaque appel fetch/XHR/WebSocket que votre navigateur effectue sur chaque site web. C'est puissant mais intrusif par conception.

Masquage des en-têtes d'authentification (v1.1.0+) : Les valeurs des en-têtes d'authentification (tokens Bearer, tokens CSRF, cookies, identifiants de session) sont masquées au moment de la capture avant stockage. IndexedDB ne stocke que les noms des en-têtes, pas les valeurs. Lorsque --auto-headers exécute un appel API, il récupère les en-têtes d'authentification en direct depuis le navigateur via CDP en temps réel — il ne rejoue jamais les identifiants stockés.

Ce que vous devez savoir :

Recommandations :

Examinez périodiquement les domaines capturés : neo capture domains
Supprimez les captures sensibles : neo capture clear banksite.com
N'installez pas Neo sur des machines partagées où d'autres ont un accès local
Le port CDP (9222) ne doit pas être exposé au-delà de localhost

Neo est un outil de développement qui échange une surface de confidentialité contre des capacités. Utilisez-le en connaissance de cause.

Pile Technique

TypeScript, Vite (construction multi-entrée)
Chrome Manifest V3
Dexie.js (wrapper IndexedDB)
Chrome DevTools Protocol pour la communication CLI ↔ navigateur
Aucun serveur backend, aucune dépendance externe au moment de l'exécution

Roadmap

Licence

MIT

Périmètre de capture	`<all_urls>` — Neo voit le trafic sur tous les sites, y compris banques, emails, portails médicaux
Script de contenu	S'exécute dans le monde `MAIN` (partage le contexte JS avec les pages) pour intercepter fetch/XHR
Port CDP	La CLI nécessite Chrome sur le port 9222 — tout processus local peut se connecter à ce port
Corps des réponses	Stockés dans IndexedDB (tronqués à 100 Ko) — peuvent contenir des données personnelles provenant des réponses API
Fichiers de schéma	Stockent uniquement la structure des points de terminaison (chemins, noms d'en-têtes, formes des réponses) — aucun identifiant ni donnée utilisateur
Exportation	`neo capture export` masque l'authentification par défaut ; `--include-auth` nécessite une adhésion explicite

Populaires

neo

Neo