Neo

Mach jede Web-App zur API. Keine offizielle API nötig. Keine Browser-Automatisierung.

Neo ist eine Chrome-Erweiterung, die passiv jeden API-Aufruf deines Browsers aufzeichnet, die Muster lernt und KI (oder dir) ermöglicht, sie direkt wiederzugeben.

Das Problem

KI-Agenten, die Web-Apps bedienen, haben heute zwei Optionen, beide schlecht:

Ansatz	Problem
Offizielle APIs	Die meisten SaaS haben keine oder legen nur 10% der Funktionen offen
Browser-Automatisierung	Screenshot → OCR → Klick. Langsam, fragil, bricht bei jeder UI-Änderung

Neo ist der dritte Weg. Jede Web-App hat bereits eine vollständige interne API – das Frontend ruft sie bei jedem Klick auf. Neo zeichnet diese Aufrufe auf und macht sie wiederholbar.

v2: Jetzt mit UI-Automatisierung. Neo v2 fügt eine auf dem Accessibility-Baum basierte UI-Ebene hinzu – snapshot, click, fill, type, press, hover, scroll, select, screenshot, get, wait. Wenn eine API existiert, nutze sie direkt. Wenn nicht, kann Neo die UI über dieselbe CLI steuern. Ein Werkzeug, beide Ebenen.

So funktioniert es

Normal browsen → Neo zeichnet allen API-Traffic auf → Schema automatisch generiert → KI spielt APIs direkt ab
                                                                      → Oder steuert UI über a11y-Baum

1. Erfassung (immer an)

Die Chrome-Erweiterung fängt jeden fetch()- und XMLHttpRequest-Aufruf ab – URLs, Header, Request-/Response-Bodies, Timing, sogar welches DOM-Element den Aufruf ausgelöst hat.

2. Lernen

Führe neo-schema für eine Domain aus, um automatisch ihre API-Karte zu generieren: Endpunkte, erforderliche Auth-Header, Abfrageparameter, Antwortstruktur, Fehlercodes.

3. Ausführung

Führe API-Aufrufe im Kontext des Browser-Tabs über das Chrome DevTools Protocol aus. Cookies, CSRF-Tokens, Session-Auth – alles automatisch vererbt. Kein Token-Management nötig.

Unterstützte Browser

Browser	Typ	Am besten geeignet für
Chrome / Chromium	Vollständiger Browser	API-Erfassung + UI-Automatisierung (Standard)
Lightpanda	Headless (Zig)	KI-Agenten, Scraping – 11x schneller, 9x weniger Speicher

Schnellstart

git clone https://github.com/4ier/neo.git
cd neo && npm install && npm run build
npm link  # macht `neo` global verfügbar

Lade die Erweiterung:

Öffne chrome://extensions
Aktiviere „Entwicklermodus"
Klicke auf „Entpackte Erweiterung laden" → wähle extension/dist/ aus
Durchsurfe eine beliebige Website – Neo beginnt sofort mit der Erfassung

Lightpanda (headless, keine Erweiterung nötig)

# Lightpanda installieren
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/

# Neo für Lightpanda konfigurieren
# In ~/.neo/config.json:
# { "chromePath": "/usr/local/bin/lightpanda", "browserType": "lightpanda", "cdpPort": 9222 }

neo start    # startet Lightpanda CDP-Server
neo connect  # verbinden
neo open https://example.com
neo snapshot # vollständiger a11y-Baum

CLI-Werkzeuge

Alle Befehle laufen über eine einzige CLI: neo <command>.

Erfordert einen Browser mit aktiviertem CDP (Chrome DevTools Protocol).

# --- Verbindung und Sitzungen ---
neo connect [port]                          # CDP verbinden, Sitzung speichern
neo connect --electron <app-name>           # Electron-App-CDP-Port automatisch finden
neo launch <app> [--port N]                 # Electron-App mit CDP starten
neo discover                                # Erreichbare CDP-Endpunkte auf localhost finden
neo sessions                                # Gespeicherte Sitzungen auflisten
neo tab                                     # CDP-Ziele in aktiver Sitzung auflisten
neo tab <index> | neo tab --url <pattern>   # Aktives Tab-Ziel wechseln
neo inject [--persist] [--tab pattern]      # Neo-Erfassungsskript in Ziel injizieren

# --- Erfassung und Traffic ---
neo status                                  # Überblick über erfasste Daten
neo capture summary                         # Kurzer Überblick
neo capture list github.com --limit 10      # Zeigt IDs für Wiedergabe/Detail an
neo capture list --since 1h                 # Zeitgefiltert
neo capture domains
neo capture search "CreateTweet" --method POST
neo capture watch x.com                     # Live-Verfolgung (wie tail -f)
neo capture stats x.com                     # Methoden-/Status-/Timing-Aufschlüsselung
neo capture export x.com --since 2h > x.json
neo capture export x.com --format har > x.har  # HAR 1.2 für Postman/devtools
neo capture import x-captures.json
neo capture prune --older-than 7d
neo capture gc x.com [--dry-run]            # Intelligentes Deduplizieren

# --- API-Wiedergabe und Ausführung ---
neo replay <capture-id> --tab x.com         # Erfassten Aufruf wiedergeben
neo exec <url> --method POST --body '{...}' --tab example.com --auto-headers
neo api x.com HomeTimeline                  # Intelligenter Aufruf (Schema-Suche + Auto-Auth)

# --- Schema und Analyse ---
neo schema generate x.com                   # Aus Erfassungen generieren
neo schema generate --all                   # Alle Domains stapelweise
neo schema show x.com [--json]
neo schema openapi x.com                    # OpenAPI 3.0-Spezifikation exportieren
neo schema diff x.com                       # Änderungen zur vorherigen Version
neo schema coverage                         # Domains mit/ohne Schema
neo label x.com [--dry-run]                 # Semantische Endpunkt-Beschriftungen
neo flows x.com [--window 5000]             # API-Aufruf-Sequenzmuster
neo deps x.com [--min-confidence 1]         # Datenabhängigkeiten Response→Request
neo workflow discover|show|run <name>       # Mehrschritt-Workflow-Erkennung und -Wiedergabe
neo suggest x.com                           # KI-Fähigkeitsanalyse
neo export-skill x.com                      # Agentenfertige SKILL.md generieren

# --- UI-Automatisierung (v2) ---
neo snapshot [-i] [-C] [--json]             # A11y-Baum mit @ref-Zuordnung
neo click @ref [--new-tab]                  # Element per @ref klicken
neo fill @ref "text"                        # Eingabe leeren + füllen
neo type @ref "text"                        # Text an Eingabe anhängen
neo press <key>                             # Tastaturtaste (unterstützt Strg+a, Eingabe usw.)
neo hover @ref                              # Über Element hoveren
neo scroll <dir> [px] [--selector css]      # In Richtung scrollen
neo select @ref "value"                     # Dropdown-Wert setzen
neo screenshot [path] [--full] [--annotate] # Screenshot aufnehmen
neo get text @ref | neo get url | neo get title  # Info extrahieren
neo wait @ref | neo wait --load networkidle | neo wait <ms>  # Auf Element/Laden/Zeit warten

# --- Seiteninteraktion ---
neo read github.com                         # Lesbaren Text extrahieren
neo eval "document.title" --tab github.com  # JS auf der Seite ausführen
neo open https://example.com                # URL öffnen

# --- Mock und Bridge ---
neo mock x.com [--port 8080 --latency 200]  # Mock-Server aus Schema
neo bridge [--json] [--interactive]          # Echtzeit-WebSocket-Erfassungsstream

# --- Diagnose ---
neo doctor                                  # Chrome, Erweiterung, Schemas prüfen
neo reload                                  # Erweiterung von CLI neu laden
neo tabs [filter]                           # Offene Chrome-Tabs auflisten

Sitzungen und Multi-App-Unterstützung

Neo ist nicht nur für Chrome. Jede App mit CDP-Unterstützung funktioniert – einschließlich Electron-Apps:

# VS Code mit CDP starten und verbinden
neo launch code --port 9230
neo snapshot                # Siehe VS Code's Accessibility-Baum
neo click @14               # Menüpunkt klicken

# Oder mit einer bereits laufenden Electron-App verbinden
neo connect --electron slack

# Neo-Erfassungsskript in jedes CDP-Ziel injizieren
neo inject --persist        # Überlebt Seitennavigation
neo inject --tab slack      # Bestimmtes Tab anvisieren

Sitzungen werden automatisch gespeichert. Wechsle zwischen ihnen mit --session:

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

UI-Automatisierung (v2)

Neo v2 fügt eine vollständige UI-Interaktionsebene hinzu, die auf dem Accessibility-Baum basiert – keine Screenshots, keine Koordinaten, keine Pixel-Matching:

# 1. Mach einen Schnappschuss – jedes interaktive Element erhält eine @ref
neo snapshot
#  @1  button "Anmelden"
#  @2  textbox "Suche"
#  @3  link "Preise"

# 2. Interagiere per @ref
neo click @1
neo fill @2 "KI-Agenten"
neo press Enter
neo screenshot results.png --full

Das gibt KI-Agenten eine schnelle, semantische Möglichkeit, mit jeder UI zu interagieren. Kombiniere es mit der API-Erfassung für einen dualen Kanal: Nutze APIs, wenn sie existieren, falle auf UI zurück, wenn nicht.

Die Bridge erstellt einen persistenten WebSocket-Kanal zwischen der Erweiterung und der CLI. Die Erweiterung verbindet sich automatisch mit ws://127.0.0.1:9234 und streamt jede Erfassung in Echtzeit. Im interaktiven Modus kannst du die Erweiterung direkt abfragen: ping, status, capture.count, capture.list, capture.domains, capture.search, capture.clear.

Architektur

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

Realwelt-Demo

Tweet über erfasste API posten

# 1. Browse X normal – Neo zeichnet GraphQL-Mutationen auf
neo schema show api.x.com

# 2. Finde den CreateTweet-Endpunkt
neo capture search "CreateTweet" --method POST

# 3. Gib mit der ursprünglichen Authentifizierung wieder (Cookies automatisch übernommen)
neo replay abc123 --tab x.com

# 4. Oder erstelle einen neuen Aufruf mit automatisch erkannten Auth-Headern
neo exec "https://x.com/i/api/graphql/.../CreateTweet" \
  --method POST --auto-headers \
  --body '{"variables":{"tweet_text":"Hello from Neo!"},...}'

Verstehen, was ein Button macht

Neos Trigger-Tracking ordnet UI-Interaktionen API-Aufrufen zu:

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

API-Traffic live überwachen

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]

Speicher

Pro-Domain-Obergrenze: Maximal 500 Erfassungen pro Domain, älteste automatisch gelöscht
Body-Kürzung: Antwort-Bodies auf 100 KB begrenzt
Ort: Chromes IndexedDB (Datenbank neo-capture-v01)
Schemas: Als JSON-Dateien exportierbar zur geräteübergreifenden Persistenz

Intelligente Filterung

Der Interceptor ignoriert automatisch Rauschen:

Statische Assets (Bilder, Schriftarten, CSS, JS-Bundles)
Analyse-/Tracking-Dienste (Google Analytics, Meta Pixel, Sentry usw.)
Browser-Interna (chrome-extension://, data:, blob:)
Ratenbegrenzung: Max. 3 Erfassungen pro URL-Muster pro Minute (verhindert Aufblähen durch Polling-Endpunkte)

Sicherheit & Datenschutz

Neo läuft vollständig lokal – keine externen Server, keine Telemetrie, keine Daten verlassen deinen Rechner.

Was Neo erfasst: Jeden fetch/XHR/WebSocket-Aufruf, den dein Browser auf jeder Website tätigt. Das ist leistungsstark, aber von Natur aus invasiv.

Auth-Header-Schwärzung (v1.1.0+): Auth-Header-Werte (Bearer-Tokens, CSRF-Tokens, Cookies, Session-IDs) werden zum Zeitpunkt der Erfassung vor der Speicherung geschwärzt. IndexedDB speichert nur Header-Namen, nicht Werte. Wenn --auto-headers einen API-Aufruf ausführt, werden die Live-Auth-Header in Echtzeit über CDP aus dem Browser geholt – es werden niemals gespeicherte Anmeldeinformationen wiederholt.

Was du wissen solltest:

Empfehlungen:

Überprüfe regelmäßig die erfassten Domains: neo capture domains
Lösche sensible Erfassungen: neo capture clear banksite.com
Installiere Neo nicht auf gemeinsam genutzten Maschinen, auf denen andere lokalen Zugriff haben
Der CDP-Port (9222) sollte nicht über localhost hinaus exponiert werden

Neo ist ein Entwicklerwerkzeug, das Privatsphäre gegen Fähigkeiten eintauscht. Nutze es wissentlich.

Technologie-Stack

TypeScript, Vite (Multi-Entry-Build)
Chrome Manifest V3
Dexie.js (IndexedDB-Wrapper)
Chrome DevTools Protocol für CLI ↔ Browser-Kommunikation
Kein Backend-Server, keine externen Abhängigkeiten zur Laufzeit

Fahrplan

Lizenz

MIT

Erfassungsumfang	`<all_urls>` – Neo sieht Traffic auf jeder Website, einschließlich Banking, E-Mail, medizinische Portale
Content-Skript	Läuft in der `MAIN`-Welt (teilt JS-Kontext mit Seiten), um fetch/XHR abzufangen
CDP-Port	CLI benötigt Chrome auf Port 9222 – jeder lokale Prozess kann sich mit diesem Port verbinden
Antwort-Bodies	In IndexedDB gespeichert (auf 100 KB gekürzt) – können personenbezogene Daten aus API-Antworten enthalten
Schema-Dateien	Speichern nur Endpunktstruktur (Pfade, Headernamen, Antwortformen) – keine Anmeldedaten oder Benutzerdaten
Export	`neo capture export` schwärzt Auth standardmäßig; `--include-auth` erfordert explizite Zustimmung

Beliebteste

neo

Neo