OpenClaw Agent Dashboard

Ein ansprechendes, sicheres Echtzeit-Monitoring-Dashboard für OpenClaw-Agents. Verfolgen Sie Sitzungen, überwachen Sie die API-Nutzung, sehen Sie Kosten ein, verwalten Sie Speicherdateien und behalten Sie den Systemzustand im Blick – alles an einem Ort.

📸 Screenshots

Übersicht	Sitzungen	Kosten

Rate-Limits	Live-Feed	Logs

✨ Funktionen

• 🤖 Sitzungsverwaltung – Alle Agent-Sitzungen mit Echtzeit-Aktivitätsstatus anzeigen
• 📊 Rate-Limit-Überwachung – Claude- und Gemini-API-Nutzung über gleitende Fenster verfolgen
• 💰 Kostenanalyse – Detaillierte Ausgabenaufschlüsselung nach Modell, Sitzung und Zeitraum
• ⚡ Live-Feed – Echtzeit-Stream von Agent-Nachrichten über alle Sitzungen hinweg
• 🧠 Speicher-Viewer – Agent-Speicherdateien durchsuchen und lesen (MEMORY.md, HEARTBEAT.md, tägliche Notizen)
• 📁 Dateimanager – Workspace-Dateien, Skills und Konfigurationen anzeigen und bearbeiten, mit Sicherheitshärtung
• 📈 Systemzustand – CPU, RAM, Festplatte, Temperatur-Überwachung mit Sparklines
• 🔄 Dienststeuerung – Schnellaktionen zum Neustarten von OpenClaw, Dashboard oder anderen Diensten
• 📋 Log-Viewer – Echtzeit-Systemlogs mit automatischer Aktualisierung
• ⏰ Cron-Verwaltung – Cron-Jobs anzeigen, aktivieren/deaktivieren und manuell auslösen
• 🌐 Tailscale-Integration – Tailscale-Status, IP und verbundene Peers anzeigen
• 🎯 Aktivitäts-Heatmap – Spitzenauslastungszeiten der letzten 30 Tage visualisieren
• 🔥 Streak-Verfolgung – Tägliche Aktivitätsstränge überwachen
• 🔍 Sitzungssuche und -filterung – Nach Status, Modell, Datumsbereich filtern mit Live-Suche
• 🎨 Dunkles/Helles Theme – Umschalten zwischen dunklem und hellem Modus mit dauerhafter Einstellung
• ⌨️ Tastaturkürzel – Schnelle Navigation mit Hotkeys (1-7, Leertaste, /, Esc, ?)
• 📱 Mobil responsiv – Funktioniert auf Smartphones und Tablets
• 🔔 Browser-Benachrichtigungen – Benachrichtigungen bei Annäherung an Nutzungslimits
• 📊 Zeitleistenansicht – Visuelle Zeitleiste der Sitzungsaktivität
• 💾 Git-Aktivität – Aktuelle Commits über Ihre Repos verfolgen
• 🎛️ Claude-Nutzungs-Scraper – Echte Nutzungsdaten von der Claude Code CLI abrufen
• 🔷 Gemini-Nutzungsverfolgung – Google Gemini-Modellnutzung mit Aufschlüsselung nach Modell überwachen
• 🔀 Anbieterwechsel – Umschalten zwischen Claude- und Gemini-Nutzung auf der Übersichtskarte
• 📊 Modellauswahl – Wählen Sie das anzuzeigende Modell/Fenster (Opus, Sonnet, Pro, Flash usw.)

🚀 Schnellstart```bash

Clone the repository

git clone https://github.com/tugcantopaloglu/openclaw-dashboard.git cd openclaw-dashboard

Set your OpenClaw workspace path (optional, auto-detects if not set)

export WORKSPACE_DIR=/path/to/your/openclaw/workspace

Start the dashboard

node server.js

Besuchen Sie `http://localhost:7000` in Ihrem Browser. Beim ersten Besuch sehen Sie einen **Registrierungsbildschirm**, auf dem Sie Ihren Benutzernamen und Ihr Passwort erstellen. Nach der Registrierung melden Sie sich mit Ihren Anmeldedaten an.

## 📦 Installation

### Voraussetzungen

- **Node.js** v18 oder höher (Überprüfung mit `node --version`)
- **OpenClaw** installiert und läuft
- **Systemd** (optional, für die Dienstinstallation unter Linux)

#### Optionale Abhängigkeiten

| Tool | Erforderlich für | Installation |
|------|-----------------|--------------|
| `jq` | Docker-Verwaltungsseite | `sudo apt install jq` |
| `tmux` | Claude CLI Nutzungs-Scraper | `sudo apt install tmux` |
| `python3` | Parser für die Claude CLI-Nutzung | Normalerweise vorinstalliert |
| `docker` | Docker-Verwaltungsseite | [docs.docker.com](https://docs.docker.com/engine/install/) |

### Manuelle Installation

1. **Klonen Sie das Repository**   ```bash
   git clone https://github.com/tugcantopaloglu/openclaw-dashboard.git
   cd openclaw-dashboard

2. Umgebung konfigurieren (optional) ```bash export DASHBOARD_PORT=7000 export WORKSPACE_DIR=/path/to/your/workspace export OPENCLAW_DIR=$HOME/.openclaw export OPENCLAW_AGENT=main
   root@kitploit:~

3. Server starten ```bash node server.js
   root@kitploit:~

Der Server wird ausgeben: ``` 🚀 Dashboard running on http://localhost:7000 🔑 Recovery token: abc123def456...

**Speichern Sie den Wiederherstellungs-Token** — Sie werden ihn brauchen, falls Sie Ihr Passwort vergessen.

4. **Auf das Dashboard zugreifen**
Öffnen Sie `http://localhost:7000` und registrieren Sie Ihr Konto.

### Systemd-Dienst (install.sh)

Um das Dashboard als Systemdienst mit automatischem Start und Absturzwiederherstellung auszuführen:```bash
sudo ./install.sh

Dies wird:

• Erstellen von /etc/systemd/system/agent-dashboard.service
• Erstellen der Überschreibungskonfiguration unter /etc/systemd/system/agent-dashboard.service.d/override.conf
• Aktivieren und Starten des Dienstes
• Festlegen Ihres Arbeitsbereichspfads und Generieren eines Wiederherstellungs-Tokens

Logs anzeigen:```bash journalctl -u agent-dashboard -f

### Docker```bash
# Build
docker build -t openclaw-dashboard .

# Run
docker run -d \
  --name openclaw-dashboard \
  -p 3001:3001 \
  -e WORKSPACE_DIR=/app/workspace \
  -e DASHBOARD_ALLOW_HTTP=true \
  -v ~/.openclaw:/home/node/.openclaw:ro \
  -v ~/.openclaw/workspace:/app/workspace \
  openclaw-dashboard

Für den Zugriff auf die Docker-Verwaltungsseite übergeben Sie den Docker-Socket:```bash docker run -d
--name openclaw-dashboard
-p 3001:3001
-e WORKSPACE_DIR=/app/workspace
-e DASHBOARD_ALLOW_HTTP=true
-v ~/.openclaw:/home/node/.openclaw:ro
-v ~/.openclaw/workspace:/app/workspace
-v /var/run/docker.sock:/var/run/docker.sock:ro
--group-add $(stat -c '%g' /var/run/docker.sock)
openclaw-dashboard

### Umgebungsvariablen

| Variable | Beschreibung | Standard |
|----------|--------------|----------|
| `DASHBOARD_PORT` | Server-Port | `7000` |
| `DASHBOARD_TOKEN` | Wiederherstellungs-Token für Passwort-Reset | Automatisch beim Start generiert |
| `WORKSPACE_DIR` | OpenClaw-Arbeitsbereichspfad | `$OPENCLAW_WORKSPACE` oder aktuelles Verzeichnis |
| `OPENCLAW_DIR` | OpenClaw-Konfigurationsverzeichnis | `~/.openclaw` |
| `OPENCLAW_AGENT` | Zu überwachende Agent-ID | `main` |
| `DASHBOARD_ALLOW_HTTP` | HTTP von nicht-lokalen IPs zulassen | `false` |

**Beispiele:**```bash
# Custom port
DASHBOARD_PORT=8080 node server.js

# Custom recovery token
DASHBOARD_TOKEN=my_secret_token_12345 node server.js

# Different workspace
WORKSPACE_DIR=/mnt/data/openclaw node server.js

🔐 Authentifizierung

Das Dashboard verwendet Benutzername- und Passwort-Authentifizierung mit sicheren serverseitigen Sitzungen.

Erstmalige Registrierung

1. Rufen Sie die Dashboard-URL auf (z.B. http://localhost:7000)
2. Sie sehen einen Registrierungsbildschirm
3. Wählen Sie einen Benutzernamen und ein Passwort
4. Klicken Sie auf Registrieren
5. Melden Sie sich mit Ihren neuen Anmeldedaten an

Anmeldung

• Geben Sie Ihren Benutzernamen und Ihr Passwort ein
• Aktivieren Sie optional „Angemeldet bleiben“, um 3 Stunden lang angemeldet zu bleiben (verwendet localStorage)
• Ohne „Angemeldet bleiben“ endet Ihre Sitzung, sobald Sie den Browser schließen (verwendet sessionStorage)

Passwortsicherheit

• PBKDF2-Hashing — 100.000 Iterationen mit SHA-512
• Zufälliger Salt — Einzigartig pro Passwort
• Serverseitige Sitzungen — Passwörter werden nie im Browser gespeichert, nur Sitzungstoken
• Zeitlich sichere Vergleiche — Verhindert Timing-Angriffe bei der Passwortüberprüfung

Ratenbegrenzung

Um Brute-Force-Angriffe zu verhindern:

• 5 fehlgeschlagene Anmeldeversuche → 15-minütige weiche Sperre
• 20 fehlgeschlagene Anmeldeversuche → Harte Sperre (erfordert Neustart des Dienstes)
• Ratenbegrenzungen sind im Arbeitsspeicher und werden beim Neustart des Dienstes zurückgesetzt

🔑 Multi-Faktor-Authentifizierung (MFA)

Fügen Sie eine zusätzliche Sicherheitsebene mit zeitbasierten Einmalpasswörtern (TOTP) hinzu.

Aktivieren der MFA

1. Melden Sie sich am Dashboard an
2. Gehen Sie zur Sicherheit-Seite (Seitenleiste)
3. Klicken Sie auf „MFA aktivieren“
4. Ein QR-Code erscheint — scannen Sie ihn mit Ihrer Authenticator-App:
   • Google Authenticator (iOS, Android)
   • Authy (iOS, Android, Desktop)
   • Microsoft Authenticator (iOS, Android)
   • 1Password, Bitwarden oder jede TOTP-kompatible App
5. Geben Sie den 6-stelligen Code aus Ihrer App ein, um zu verifizieren
6. MFA ist jetzt aktiv! 🎉

Verwenden der MFA

Einmal aktiviert, erfordert jede Anmeldung:

1. Ihren Benutzernamen und Ihr Passwort (wie gewohnt)
2. Einen 6-stelligen TOTP-Code von Ihrer Authenticator-App

• Codes aktualisieren sich alle 30 Sekunden
• Das Dashboard akzeptiert Codes mit ±1 Fenstertoleranz für Uhrabweichungen (30 Sekunden davor/danach)

Deaktivieren der MFA

1. Gehen Sie zur Sicherheit-Seite
2. Klicken Sie auf „MFA deaktivieren“
3. Geben Sie Ihren aktuellen 6-stelligen TOTP-Code ein, um zu bestätigen
4. MFA ist jetzt deaktiviert

Zurücksetzen der MFA (bei Aussperrung)

Wenn Sie den Zugriff auf Ihre Authenticator-App verlieren (Telefon verloren, App deinstalliert usw.):

1. Stellen Sie eine SSH-Verbindung zu Ihrem Server her
2. Führen Sie diesen Befehl aus, um das MFA-Geheimnis zu löschen: ```bash node -e "const fs=require('fs');const c=JSON.parse(fs.readFileSync('/root/clawd/data/credentials.json','utf8'));delete c.mfaSecret;fs.writeFileSync('/root/clawd/data/credentials.json',JSON.stringify(c,null,2));console.log('MFA cleared')"
   root@kitploit:~

3. Dashboard neu starten: ```bash systemctl restart agent-dashboard
   root@kitploit:~

4. Melden Sie sich nur mit Ihrem Benutzernamen und Passwort an
5. Aktivieren Sie MFA mit einem neuen QR-Code erneut

Wichtig: Passen Sie den Pfad /root/clawd/data/credentials.json an, falls Ihr Arbeitsbereich woanders liegt.

🔓 Passwort-Wiederherstellung

Passwort vergessen?

Wenn Sie Ihr Passwort vergessen:

1. Klicken Sie auf dem Anmeldebildschirm auf "Passwort vergessen?"
2. Geben Sie Ihren Wiederherstellungs-Token ein (siehe "Wiederherstellungs-Token finden" unten)
3. Legen Sie ein neues Passwort fest
4. Melden Sie sich mit Ihrem neuen Passwort an

Wiederherstellungs-Token finden

Der Wiederherstellungs-Token (DASHBOARD_TOKEN) wird beim Start des Servers ausgegeben. Sie finden ihn an mehreren Stellen:

Überprüfen Sie die Server-Startprotokolle```bash

journalctl -u agent-dashboard | grep "Recovery token"

Ausgabe:```
🔑 Recovery token: 3e6b91f352418b486a9aa9d82fbbc1b1

Systemd-Override-Konfiguration überprüfen```bash

cat /etc/systemd/system/agent-dashboard.service.d/override.conf

Suchen Sie nach:```ini
Environment=DASHBOARD_TOKEN=3e6b91f352418b486a9aa9d82fbbc1b1

Umgebungsvariable überprüfen

Wenn Sie sie manuell gesetzt haben:```bash echo $DASHBOARD_TOKEN

### Ändern Ihres Passworts

Um Ihr Passwort zu ändern, während Sie angemeldet sind:

1. Gehen Sie zur **Sicherheits**-Seite
2. Geben Sie Ihr **aktuelles Passwort** ein
3. Geben Sie Ihr **neues Passwort** ein
4. Klicken Sie auf **"Passwort ändern"**
5. Alle anderen Sitzungen werden ungültig (Sie müssen sich an anderer Stelle erneut anmelden)

### Vollständiger Account-Reset (Atomoption)

Wenn alles gesperrt ist und Sie sich nicht anmelden können:

1. **SSH in Ihren Server einloggen**
2. **Löschen Sie die Anmeldedatendatei**:
```   ```bash
   rm /root/clawd/data/credentials.json

3. Starten Sie das Dashboard neu: ```bash systemctl restart agent-dashboard
   root@kitploit:~

4. Dashboard aufrufen — der Registrierungsbildschirm erscheint
5. Ein neues Konto von Grund auf erstellen

Warnung: Dabei werden Ihr Benutzername, Passwort und MFA-Einstellungen gelöscht. Speicherdateien und Prüfprotokolle sind nicht betroffen.

🛡️ Sicherheitsfunktionen

Das Dashboard ist nach den besten Sicherheitspraktiken aufgebaut:

• PBKDF2-Passwort-Hashing — 100.000 Iterationen, SHA-512, zufälliger Salt
• Zeitsichere Vergleiche — Verhindert Timing-Angriffe bei der Token-/Passwort-Überprüfung
• Serverseitige Sitzungen — Sitzungstokens werden im Speicher gehalten, Passwörter werden niemals an den Browser gesendet
• Ratenbegrenzung — Einheitlicher Ratenbegrenzer für Anmeldeversuche (5 weiche / 20 harte Sperre)
• HTTPS-Erzwingung — HTTP wird blockiert, außer von localhost und Tailscale (100.64.0.0/10)
• Sicherheitsheader:
  • HSTS — HTTPS für zukünftige Besuche erzwingen
  • CSP — Content Security Policy (keine Inline-Skripte, same-origin)
  • X-Frame-Options: DENY — Clickjacking verhindern
  • X-Content-Type-Options: nosniff — MIME-Sniffing verhindern
  • X-XSS-Protection: 1; mode=block — Legacy-XSS-Schutz
• Prüfprotokollierung — Alle Authentifizierungsereignisse und destruktiven Aktionen werden in data/audit.log protokolliert
• CORS — Nur same-origin, kein Wildcard (*) erlaubt
• Eingabevalidierung:
  • Service-Whitelist für Protokolle und Aktionen
  • Pfad-Traversal-Schutz für Dateizugriff
  • Nutzlastgrößenbegrenzungen (max. 1 MB)
• Automatische Backups — .bak-Dateien werden vor dem Überschreiben von Arbeitsbereichsdateien erstellt

🌐 Netzwerksicherheit

Das Dashboard ist für den lokalen oder Tailscale-Zugriff ausgelegt:

Empfohlene Zugriffsmethoden

1. Localhost — Zugriff vom selben Rechner: http://localhost:7000
2. Tailscale — Zugriff über Ihr Tailscale-Netzwerk: http://100.x.x.x:7000
   • Tailscale bietet automatische TLS-Verschlüsselung (MagicDNS + HTTPS)
   • Tailscale-IPs (100.64.0.0 bis 100.127.255.255) sind von der HTTPS-Erzwingung ausgenommen
3. Lokales Netzwerk — Zugriff aus dem LAN (HTTPS verwenden oder DASHBOARD_ALLOW_HTTP=true setzen)

HTTPS-Erzwingung

Standardmäßig blockiert das Dashboard HTTP-Zugriff von nicht-lokalen IPs. Ausnahmen:

• Localhost (127.0.0.1, ::1)
• Tailscale-IPs (100.64.0.0/10)

Für andere Netzwerke erfordert das Dashboard HTTPS oder den X-Forwarded-Proto: https-Header (von einem Reverse-Proxy).

Um HTTP von allen IPs zuzulassen (nicht empfohlen):```bash DASHBOARD_ALLOW_HTTP=true node server.js

### Nicht dem öffentlichen Internet aussetzen

**Dieses Dashboard ist NICHT für die öffentliche Internet-Exposition gehärtet.** Obwohl es Authentifizierung und Ratenbegrenzung hat, ist es für private Netzwerke konzipiert. Wenn Sie es dennoch freigeben müssen:
- Verwenden Sie einen Reverse-Proxy (nginx, Caddy) mit HTTPS
- Fügen Sie eine IP-Zulassungsliste hinzu
- Ziehen Sie stattdessen VPN (Tailscale, WireGuard) in Betracht

## 🛠️ Fehlerbehebung

### "Zu viele fehlgeschlagene Versuche"

**Problem:** Sie sehen "Zu viele fehlgeschlagene Anmeldeversuche. Bitte versuchen Sie es später erneut."

**Lösungen:**
- Warten Sie **15 Minuten**, bis die weiche Sperre abläuft
- Starten Sie den Dienst neu, um die Ratenbegrenzungen zu löschen:
`sudo systemctl restart your-service`  ```bash
  systemctl restart agent-dashboard

• Ratenbegrenzungen sind im Arbeitsspeicher und werden beim Neustart zurückgesetzt

Kein Login nach Passwortänderung möglich

Problem: Ihr Passwort wurde geändert, aber Sie können sich nicht anmelden.

Lösung: Verwenden Sie den "Passwort vergessen?"-Ablauf mit Ihrem Wiederherstellungs-Token, um ein neues Passwort festzulegen.

MFA-Code funktioniert nicht

Problem: Der 6-stellige TOTP-Code wird abgelehnt.

Lösungen:

• Stellen Sie sicher, dass die Uhr Ihres Telefons synchronisiert ist:
  • iOS: Einstellungen → Allgemein → Datum & Uhrzeit → Automatisch einstellen
  • Android: Einstellungen → System → Datum & Uhrzeit → Automatisches Datum & Uhrzeit
• TOTP-Codes haben eine Toleranz von ±30 Sekunden für Uhrzeitabweichungen
• Versuchen Sie, den nächsten Code einzugeben (warten Sie 30 Sekunden auf die Aktualisierung)
• Wenn es weiterhin fehlschlägt, MFA per SSH zurücksetzen (siehe Abschnitt "MFA zurücksetzen")

Dashboard lädt nicht

Problem: Der Browser zeigt eine leere Seite oder einen Verbindungsfehler an.

Lösungen:

1. Service-Status prüfen: ```bash systemctl status agent-dashboard
   root@kitploit:~

2. Logs prüfen: ```bash journalctl -u agent-dashboard -n 50
   root@kitploit:~

3. Port überprüfen: ```bash curl http://localhost:7000/api/auth/status
   root@kitploit:~

Sollte zurückgeben: ```json {"authenticated": false, "requiresRegistration": false}

### Fehler "HTTPS erforderlich"

**Problem:** Der Browser zeigt "HTTPS erforderlich. Zugriff über localhost, Tailscale, oder HTTPS aktivieren." an.

**Lösungen:**
- Zugriff über **localhost**: `http://localhost:7000`
- Zugriff über **Tailscale**: `http://100.x.x.x:7000`
- Setze `DASHBOARD_ALLOW_HTTP=true` in der Umgebung (nicht empfohlen):  ```bash
# Add to /etc/systemd/system/agent-dashboard.service.d/override.conf
Environment=DASHBOARD_ALLOW_HTTP=true

# Reload and restart
systemctl daemon-reload
systemctl restart agent-dashboard

Leere Seite nach Update

Problem: Das Dashboard zeigt eine leere Seite nach dem Abrufen neuen Codes.

Lösungen:

• Hartes Neuladen: Ctrl+Shift+R (Windows/Linux) oder Cmd+Shift+R (macOS)
• Browser-Cache leeren für die Dashboard-URL
• Browser-Konsole prüfen (F12 → Konsole-Tab) auf JavaScript-Fehler

📡 API-Referenz

Das Dashboard stellt eine REST-API für den programmatischen Zugriff bereit. Alle Endpunkte erfordern eine Authentifizierung über den Header Authorization: Bearer <sessionToken>.

Nicht authentifizierte Endpunkte

• GET /api/auth/status — Authentifizierungsstatus prüfen
• POST /api/auth/login — Mit Benutzername/Passwort anmelden (+ TOTP falls MFA aktiviert)
• POST /api/auth/register — Neues Konto registrieren (nur wenn keine Anmeldedaten existieren)
• POST /api/auth/reset-password — Passwort mit Wiederherstellungs-Token zurücksetzen

Authentifizierte Endpunkte

Alle anderen Endpunkte erfordern Authentifizierung:

• GET /api/config — Dashboard-Konfiguration
• GET /api/sessions — Alle Agentensitzungen auflisten
• GET /api/usage — Nutzungsdaten für ein rollierendes 5-Stunden-Fenster
• GET /api/costs — Ausgabendaten nach Tag, Modell und Sitzung
• GET /api/system — System-Gesundheitsmetriken
• GET /api/memory-files — Speicherdateien auflisten
• GET /api/memory-file?path=<path> — Speicherdatei lesen
• GET /api/key-files — Arbeitsbereichsdateien auflisten (Fähigkeiten, Konfigurationen)
• GET /api/key-file?path=<name> — Arbeitsbereichsdatei lesen
• POST /api/key-file — In eine Arbeitsbereichsdatei schreiben (mit Backup)
• GET /api/crons — Cron-Jobs auflisten
• POST /api/cron/<id>/toggle — Cron-Job aktivieren/deaktivieren

Detaillierte Anfrage-/Antwortbeispiele finden Sie in der vorherigen Version dieser README oder erkunden Sie die API im Netzwerk-Tab des Browsers.

📂 Datendateien

Das Dashboard speichert Daten in Ihrem Arbeitsbereichsverzeichnis:

Struktur der Anmeldedatendatei:```json { "username": "admin", "passwordHash": "pbkdf2_sha512$100000$...", "salt": "...", "mfaSecret": "BASE32SECRET..." // Only if MFA enabled }

## 🔗 OpenClaw-Integration

Das Dashboard erkennt automatisch:
- **Sitzungen** aus `$OPENCLAW_DIR/agents/$AGENT_ID/sessions/`
- **Cron-Jobs** aus `$OPENCLAW_DIR/cron/jobs.json`
- **Speicherdateien** aus `$WORKSPACE_DIR/MEMORY.md`, `HEARTBEAT.md` und `memory/*.md`
- **Git-Repos** aus `$WORKSPACE_DIR/projects/*/`
- **Gesundheitsdaten** gespeichert in `$WORKSPACE_DIR/data/health-history.json`

### Erforderliche Dateien

Das Dashboard funktioniert am besten, wenn diese Dateien vorhanden sind:
- `$WORKSPACE_DIR/MEMORY.md` - Langzeitspeicher des Agenten
- `$WORKSPACE_DIR/HEARTBEAT.md` - Heartbeat-Aufgabenliste
- `$WORKSPACE_DIR/memory/YYYY-MM-DD.md` - Tägliche Gedächtnisnotizen
- `$WORKSPACE_DIR/scripts/scrape-claude-usage.sh` - Claude-Nutzungs-Scraper
- `$WORKSPACE_DIR/scripts/parse-claude-usage.py` - Claude-Nutzungs-Parser
- `$WORKSPACE_DIR/scripts/scrape-gemini-usage.sh` - Gemini-Nutzungs-Scraper
- `$WORKSPACE_DIR/scripts/parse-gemini-usage.py` - Gemini-Nutzungs-Parser

## ⌨️ Tastaturkürzel

| Taste | Aktion |
|-------|--------|
| `1` | Zu Übersicht wechseln |
| `2` | Zu Sitzungen wechseln |
| `3` | Zu Kosten wechseln |
| `4` | Zu Ratenbegrenzungen wechseln |
| `5` | Zu Speicher wechseln |
| `6` | Zu Dateien wechseln |
| `7` | Zu Live-Feed wechseln |
| `8` | Zu Protokollen wechseln |
| `9` | Zu Sicherheit wechseln |
| `Space` | Feed anhalten/fortsetzen (auf der Live-Feed-Seite) |
| `/` | Suchfeld fokussieren |
| `Esc` | Modale und Überlagerungen schließen |
| `?` | Tastaturkürzel-Hilfe anzeigen |

## 🤝 Mitwirken

Beiträge sind willkommen! Bitte befolgen Sie diese Richtlinien:

1. **Forken** Sie das Repository
2. **Erstellen** Sie einen Feature-Branch (`git checkout -b feature/amazing-feature`)
3. **Comitten** Sie Ihre Änderungen (`git commit -m 'Add amazing feature'`)
4. **Pushen** Sie auf den Branch (`git push origin feature/amazing-feature`)
5. **Erstellen** Sie einen Pull Request

### Entwicklungseinrichtung```bash
git clone https://github.com/tugcantopaloglu/openclaw-dashboard.git
cd openclaw-dashboard
export WORKSPACE_DIR=/path/to/test/workspace
node server.js

Das Dashboard hat keinen Build-Schritt — bearbeite server.js oder index.html und lade neu.

Codestil

• Keine Kommentare im Code (selbsterklärend)
• Kurze und direkte Funktionsnamen

📄 Lizenz

MIT-Lizenz – siehe Datei LICENSE für Details.

🙏 Danksagungen

• Erstellt mit Claude Code
• Entwickelt für OpenClaw
• Inspiriert von modernen Dashboards (Grafana, Vercel, Railway)
• Schriftarten: Inter & JetBrains Mono

📞 Support

• Issues: GitHub Issues
• Twitter: @tugcantopaloglu

Erstellt mit ✨ von Tuğcan Topaloğlu