agentsview mit Docker: Sitzungen von Claude Code und Codex auswerten

Wer mit Claude Code, Codex oder OpenCode arbeitet, sammelt schnell Hunderte Sitzungen als JSONL-Dateien. Was hat der Agent vorige Woche an der Login-Route geändert, welches Projekt verbraucht die meisten Token? agentsview beantwortet solche Fragen über eine lokale Weboberfläche mit Volltextsuche, Sitzungsansicht und Token-Statistik. Das Go-Projekt steht unter MIT-Lizenz, hat auf GitHub rund 6.300 Sterne und lag in dieser Woche mit 137 neuen Sternen in den Go-Trends. Version 0.46.1 erschien am 23. Oktober 2026.

Diese Anleitung betreibt agentsview mit Docker Compose, liest die Sitzungsordner nur lesend ein und zeigt Token-Schutz, Sicherung, Wiederherstellung und Update. Alle Ausgaben stammen aus unserem Testlauf mit 0.45.0 und 0.46.1 und synthetischen Beispielsitzungen.

Voraussetzungen

agentsview gehört auf den Rechner, auf dem Ihre Coding-Agenten laufen: eine Entwickler-Workstation unter Linux oder ein Entwicklungsserver, auf dem Claude Code oder Codex im Terminal arbeiten. Die Sitzungsdateien müssen dort lokal liegen, denn agentsview liest sie direkt aus dem Dateisystem.

• Linux-Rechner mit x86-64 oder ARM64 (das Image gibt es für beide Architekturen). Für Docker und agentsview reicht die Ausstattung eines üblichen Entwicklungsrechners mit 2 Kernen und 4 GB RAM; die Datenbank wächst mit der Zahl der Sitzungen und belegte im Test mit drei Sitzungen 1,9 MB.
• Docker Engine mit Docker Compose Plugin, eingerichtet wie in der Anleitung Docker Compose unter Linux.
• Mindestens einer der Ordner ~/.claude/projects, ~/.codex/sessions, ~/.forge oder ~/.local/share/opencode.
• Für den Zugriff von einem anderen Rechner einen SSH-Zugang oder ein VPN; der Port bleibt auf 127.0.0.1.

Eckdaten	Wert
Image	ghcr.io/kenn-io/agentsview:0.46.1 (Tags ohne v-Präfix)
Port	8080, nur an 127.0.0.1 gebunden
Volumes	/data (Index, config.toml, Token), Agentenordner unter /agents/… schreibgeschützt
Wichtige Variablen	CLAUDE_PROJECTS_DIR, CODEX_SESSIONS_DIR, FORGE_DIR, OPENCODE_DIR, AGENTSVIEW_AUTH_TOKEN_FILE
Im Image gesetzt	AGENTSVIEW_MODE=serve, AGENTSVIEW_HOST=0.0.0.0, AGENTSVIEW_REQUIRE_AUTH=true

Schritt 1: Compose-Datei anlegen und starten

Die Vorlage entspricht der docker-compose.prod.yaml aus dem Repository, allerdings mit fester Version statt latest. Legen Sie einen Projektordner an und speichern Sie darin die compose.yaml:

mkdir -p ~/agentsview && cd ~/agentsview
nano compose.yaml

services:
  agentsview:
    image: ghcr.io/kenn-io/agentsview:0.46.1
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:8080"
    environment:
      CLAUDE_PROJECTS_DIR: /agents/claude
      CODEX_SESSIONS_DIR: /agents/codex
      FORGE_DIR: /agents/forge
      OPENCODE_DIR: /agents/opencode
    volumes:
      - agentsview-data:/data
      - ${HOME}/.claude/projects:/agents/claude:ro
      - ${HOME}/.codex/sessions:/agents/codex:ro
      - ${HOME}/.forge:/agents/forge:ro
      - ${HOME}/.local/share/opencode:/agents/opencode:ro

volumes:
  agentsview-data:

Das :ro an jedem Agentenordner ist wichtig: agentsview braucht nur Lesezugriff, und so kann ein Fehler im Parser Ihre Sitzungsdateien nicht verändern. Nutzen Sie einen Agenten nicht, entfernen Sie die Zeile; sonst legt Docker den fehlenden Ordner beim Start leer an. Die Version schreiben Sie bewusst fest. Die Registry führt die Tags ohne v, also 0.46.1 und nicht v0.46.1. Die Version 0.46.0 fehlt in der Registry ganz, zwischen 0.45.0 und 0.46.1 gibt es dort kein Image.

docker compose up -d --pull always
docker compose logs --no-log-prefix | tail -4

Watching 9 directories for changes (2 shallow) (6ms)
Polling 137 roots every 2m0s for changes
agentsview v0.46.1 listening at http://0.0.0.0:8080, browser URL: http://127.0.0.1:8080 (started in 166ms)
Database: /data/sessions.db

Beim ersten Start meldete der Container im Test Sync complete: 3 sessions synced in 180ms: zwei Claude-Code-Sitzungen und eine Codex-Sitzung aus den Beispielordnern.

Verifizieren: docker compose exec agentsview agentsview --version gibt agentsview v0.46.1 (commit 65523169, built 2026-10-22T21:19:55-05:00) aus, docker compose ps zeigt den Dienst als Up mit 127.0.0.1:8080->8080/tcp.

Schritt 2: Token auslesen und Zugriff prüfen

Das Image setzt AGENTSVIEW_REQUIRE_AUTH=true, weil es innerhalb des Containers auf 0.0.0.0 lauscht. Beim ersten Start erzeugt agentsview ein zufälliges 256-Bit-Token und schreibt es als auth_token in /data/config.toml. Das Image enthält eine Shell, Sie lesen das Token also direkt aus:

docker compose exec agentsview sh -c 'grep ^auth_token /data/config.toml'

Speichern Sie den Wert im Passwortmanager und prüfen Sie den Schutz:

TOKEN='hier-das-token-einsetzen'
curl -s -w ' HTTP %{http_code}\n' http://127.0.0.1:8080/api/ping
curl -s -w ' HTTP %{http_code}\n' -H 'Authorization: Bearer falsch' http://127.0.0.1:8080/api/v1/sessions
curl -s -H "Authorization: Bearer $TOKEN" http://127.0.0.1:8080/api/ping

Unauthorized
 HTTP 401
Unauthorized
 HTTP 401
{"ok":true,"healthy":true,"service":"agentsview","version":"v0.46.1","pid":1}

Im Browser öffnen Sie http://127.0.0.1:8080. Die Startseite selbst lädt ohne Token, alle Daten kommen aber über die API, und so erscheint zuerst ein Anmeldedialog. Dort fügen Sie das Token ein; der Browser merkt es sich im Local Storage dieser Adresse.

Wer das Token nicht in der config.toml haben möchte, legt es als Datei ab und setzt AGENTSVIEW_AUTH_TOKEN_FILE: /run/secrets/agentsview_token plus einen schreibgeschützten Mount dieser Datei. Im Test akzeptierte 0.46.1 das Token aus der Datei (HTTP 200, ohne Token 401) und schrieb dann kein auth_token mehr in die Konfiguration. Fehlt die Datei, startet der Dienst nicht. Wie Sie solche Geheimnisse sauber ablegen, zeigt die Anleitung Docker Compose absichern.

Verifizieren: Ohne und mit falschem Token liefert die API HTTP 401, mit Ihrem Token antwortet /api/ping mit "healthy":true und der Versionsnummer.

Schritt 3: Sitzungen durchsuchen

Nach der Anmeldung zeigt die linke Spalte alle erkannten Sitzungen mit Agent, Projekt und Alter. Das Projekt leitet agentsview aus dem Arbeitsverzeichnis der Sitzung ab, im Test also webshop und api. Mit Strg+K öffnen Sie die Suche. Wir hatten in einer Testsitzung das Markerwort „Fliederbaum“ versteckt; die Volltextsuche fand es sofort.

Dieselbe Suche steht als API bereit, praktisch für Skripte oder einen Bot:

curl -s -H "Authorization: Bearer $TOKEN" 'http://127.0.0.1:8080/api/v1/search?q=Fliederbaum'

{"query":"Fliederbaum","results":[{"session_id":"7d1e2f30-1111-4a2b-9c3d-000000000001","project":"webshop","agent":"claude","snippet":"Bitte den Fehler im Warenkorb beheben, Stichwort <mark>Fliederbaum</mark>"}],"count":1,"next":0}

Ein Klick auf den Treffer öffnet die Sitzung mit allen Nachrichten, Werkzeugaufrufen wie Read src/cart.ts, Modellname und Token je Antwort. Über den Stern markieren Sie wichtige Sitzungen; diese Markierung nutzen wir später als Prüfzeichen für die Wiederherstellung.

Verifizieren: Die Sitzungsliste nennt so viele Sitzungen wie Dateien in den Agentenordnern liegen, und die Suche nach einem Wort aus einer Ihrer Sitzungen liefert "count" größer 0.

Schritt 4: Token-Statistik auswerten

Die Startseite zeigt Sitzungen, Nachrichten, aktive Tage und eine Aktivitäts-Heatmap. Interessanter für die Kostenkontrolle ist die Ansicht Usage. agentsview liest die Token-Angaben aus den Sitzungsdateien und rechnet sie mit einer Preistabelle in Kosten um. Im Test ergaben die drei Beispielsitzungen 10.200 Eingabe-Token, davon 5.500 aus dem Cache, 1.300 Ausgabe-Token und rechnerisch 0,08 US-Dollar, aufgeteilt nach Projekt, Modell und Agent.

Die Kosten sind eine Schätzung nach Listenpreisen. Bei Abos sagt die Zahl nichts über Ihre Rechnung, zeigt aber, welche Projekte und Modelle den Verbrauch treiben.

Verifizieren: curl -s -H "Authorization: Bearer $TOKEN" http://127.0.0.1:8080/api/v1/analytics/summary liefert unter anderem total_sessions, total_output_tokens und die erkannten Modelle.

Schritt 5: Daten sichern

Laut Dokumentation gehören sessions.db, der Ordner assets/, die config.toml und telemetry-install-id in die Sicherung. Am einfachsten sichern Sie das ganze Volume. Die Datenbank läuft im WAL-Modus, deshalb stoppen Sie den Dienst vorher, damit keine halb geschriebenen Seiten im Archiv landen:

docker compose stop
mkdir -p backup
docker run --rm -v agentsview_agentsview-data:/data:ro -v "$PWD/backup":/backup \
  alpine tar czf /backup/agentsview-data.tgz -C /data .
docker compose start

Der Volume-Name setzt sich aus Ordnername und agentsview-data zusammen, docker volume ls zeigt ihn. Das Archiv war im Test knapp 300 KB groß.

Verifizieren: tar tzf backup/agentsview-data.tgz | grep -E 'sessions.db|config.toml' listet beide Dateien.

Schritt 6: Wiederherstellung nach Totalverlust

Um die Sicherung ehrlich zu prüfen, haben wir das Volume komplett gelöscht und neu gestartet:

docker compose down -v
docker compose up -d

Das Ergebnis ist aufschlussreich: Die drei Sitzungen waren sofort wieder da, weil agentsview sie aus den Quelldateien neu einliest. Verloren waren dagegen der Stern an der Sitzung und das Token. agentsview hatte ein neues erzeugt, das alte Token bekam HTTP 401. Ohne Sicherung fallen Markierungen, das Token und Sitzungen weg, deren Quelldateien inzwischen gelöscht sind. Die Wiederherstellung läuft wieder über einen Hilfscontainer:

docker compose stop
docker run --rm -v agentsview_agentsview-data:/data -v "$PWD/backup":/backup:ro alpine \
  sh -c 'rm -rf /data/* /data/.[!.]* 2>/dev/null; tar xzf /backup/agentsview-data.tgz -C /data'
docker compose start

curl -s -w ' HTTP %{http_code}\n' -H "Authorization: Bearer $TOKEN" http://127.0.0.1:8080/api/v1/starred
curl -s -w ' HTTP %{http_code}\n' -H "Authorization: Bearer $TOKEN_NEU" http://127.0.0.1:8080/api/v1/starred

{"session_ids":["7d1e2f30-1111-4a2b-9c3d-000000000001"]} HTTP 200
Unauthorized
 HTTP 401

Die erste Zeile verwendet das ursprüngliche Token, die zweite das Token, das die leere Neuinstallation erzeugt hatte.

Verifizieren: Nach der Rücksicherung funktioniert das alte Token wieder, /api/v1/starred listet die markierte Sitzung, und die Suche nach Ihrem Markerwort liefert denselben Treffer wie vorher.

Schritt 7: Update einspielen

Für den Update-Weg haben wir mit 0.45.0 begonnen, Sitzungen eingelesen und dann den Tag auf 0.46.1 gesetzt. Sichern Sie vorher wie in Schritt 5, ändern Sie die Versionsnummer in der compose.yaml und starten Sie neu:

sed -i 's/agentsview:0.45.0/agentsview:0.46.1/' compose.yaml
docker compose up -d --pull always
docker compose exec agentsview agentsview --version

Der Container wurde neu erstellt, der Index blieb erhalten, und das Token in /data/config.toml war vor und nach dem Update identisch. Ein wichtiger Unterschied zeigte sich aber beim Zugriffsschutz: Das Image 0.45.0 startete per Einstiegsskript nur mit --host 0.0.0.0 --no-browser und ohne Token-Pflicht. Ein curl ohne und sogar mit falschem Token bekam die komplette Sitzungsliste mit HTTP 200. Ab 0.46.1 lehnt dieselbe Anfrage mit HTTP 401 ab. Betreiben Sie noch ein älteres Image, aktualisieren Sie zügig oder setzen Sie AGENTSVIEW_REQUIRE_AUTH: "true" selbst. Prüfen Sie danach unbedingt den Fall ohne Token.

Automatische Updates per Watchtower sind hier wenig sinnvoll, weil Sie nach jedem Versionswechsel den Token-Schutz prüfen sollten. Ein Benachrichtigungsdienst wie Diun passt besser, siehe Container-Updates mit Diun und WUD.

Verifizieren: --version meldet agentsview v0.46.1, /api/ping mit Token zeigt "version":"v0.46.1", und ohne Token antwortet die API mit 401.

Troubleshooting

Meldung	Ursache und Lösung
failed to resolve reference "ghcr.io/kenn-io/agentsview:v0.46.1": not found	Die Tags tragen kein v. Schreiben Sie 0.46.1.
Forbidden: request Host "127.0.0.1:28080" is not in the allowed set [0.0.0.0:8080 127.0.0.1:8080 [::1]:8080 localhost:8080], HTTP 403	Schutz gegen DNS-Rebinding: Die API prüft den Host-Header. Im Test trat das mit dem Image 0.45.0 ohne Token-Pflicht auf, als der Port auf dem Host anders als 8080 lautete. Lassen Sie den Port bei 8080 oder tragen Sie die tatsächliche Browser-Adresse als public_url bzw. public_origins in die config.toml ein. Mit 0.46.1 und gültigem Token ließ agentsview im Test auch Anfragen über einen Reverse Proxy mit anderem Hostnamen zu.
loading config: AGENTSVIEW_AUTH_TOKEN_FILE: reading secret file: open /run/secrets/agentsview_token: no such file or directory	Die Token-Datei ist nicht gemountet. agentsview fällt bewusst nicht auf die config.toml zurück und startet nicht.
fatal: invalid serve config: host = "0.0.0.0" exposes the API beyond this machine; set require_auth = true …	AGENTSVIEW_REQUIRE_AUTH wurde auf false gesetzt. Mit AGENTSVIEW_HOST=0.0.0.0 verweigert agentsview den Start ohne Token-Pflicht, und das ist gut so.
Container läuft, aber Healthcheck mit /api/ping schlägt fehl	Auch /api/ping verlangt das Token und antwortet sonst mit 401. Die Dokumentation empfiehlt eine TCP-Prüfung auf Port 8080 oder 401 als Lebenszeichen zu werten.

Häufige Fragen

Wie greife ich vom Laptop auf einen Entwicklungsserver zu?

Lassen Sie den Port auf 127.0.0.1 und nutzen Sie einen SSH-Tunnel mit gleicher Portnummer: ssh -L 8080:127.0.0.1:8080 server, dann http://127.0.0.1:8080 im lokalen Browser öffnen. Den Port direkt ins Netz zu stellen ist keine gute Idee, auch mit Token, denn die Sitzungen enthalten Quelltext, Pfade und mitunter Geheimnisse aus Werkzeugausgaben.

Schreibt agentsview in meine Sitzungsdateien?

Mit den :ro-Mounts kann es das nicht. Index, Markierungen und Einstellungen liegen ausschließlich im Volume /data.

Sendet agentsview Daten nach außen?

Laut README sendet agentsview anonyme Nutzungsereignisse an PostHog, ohne Sitzungsinhalte, Projekte oder Pfade. Abschalten lässt sich das mit DO_NOT_TRACK=1 oder AGENTSVIEW_TELEMETRY_ENABLED=0 im Abschnitt environment. Die Preistabelle für die Kostenberechnung lädt der Dienst aus dem Netz; im Test meldete die API "source":"fetched".

Welche Agenten werden unterstützt?

Laut Projekt mehr als 50, darunter Claude Code, Codex, OpenCode, Forge, Cursor, Copilot CLI und Gemini. Weitere Ordner binden Sie schreibgeschützt ein und setzen die Variable aus der Konfigurationsdokumentation.

Fazit

agentsview macht aus verstreuten JSONL-Dateien ein durchsuchbares Archiv mit brauchbarer Kostenübersicht, und der Container ist in wenigen Minuten eingerichtet. Zwei Dinge sollten Sie aus dem Test mitnehmen: Sichern Sie /data und nicht nur die Quellordner, denn Token und Markierungen gibt es nur dort. Und verwenden Sie mindestens 0.46.1, denn das Image 0.45.0 lieferte die API im Test ohne Token aus.

Weiterführende Anleitungen und Quellen

• ai-memory mit Docker: Gedächtnis für Claude Code und Codex
• OpenCode als Docker-Server mit lokalem Ollama-Modell
• Orca: Coding-Agenten parallel in Git-Worktrees
• Docker Compose unter Linux: Grundlage für Selfhosting
• agentsview auf GitHub und Release-Notizen
• Dokumentation: Container Deployment und Remote Access
• Offizielle docker-compose.prod.yaml