# Berechtigungskonfiguration

Claude Code nutzt ein Berechtigungssystem, um zu steuern, welche Operationen eine Benutzerbestätigung erfordern. Eine sachgerechte Berechtigungskonfiguration gewährleistet sowohl Sicherheit als auch Entwicklungseffizienz.

## Vier Berechtigungsmodi

| Modus | Beschreibung | Anwendungsfall |
|------|-------------|----------|
| `default` | Fordert bei der ersten Verwendung eines Tools um Berechtigung | Tägliche Entwicklung, Balance zwischen Sicherheit und Effizienz |
| `acceptEdits` | Genehmigt Dateibearbeitungen automatisch; andere Operationen erfordern weiterhin eine Bestätigung | Aufgaben mit häufigen Dateiänderungen |
| `plan` | Nur Analyse, keine Ausführung (Plan-Modus) | Code erkunden und überprüfen, ohne dass Claude Änderungen vornimmt |
| `bypassPermissions` | Überspringt alle Berechtigungsabfragen | CI/CD-Automatisierung, vertrauenswürdige und sichere Umgebungen |

### Wechseln der Berechtigungsmodi

- Drücken Sie **`Shift+Tab`**, um die Berechtigungsmodi durchzuschalten
- Drücken Sie **`Shift+Tab`** zweimal, um den Plan-Modus zu aktivieren (Escape drücken zum Verlassen)
- Wählen Sie einen Modus direkt im Dialog aus

## Standard-Berechtigungsmodus konfigurieren

Konfigurieren Sie dies in `.claude/settings.json`:

```json
{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}
```

## Allow-Regeln: Befehle im Voraus genehmigen

Genehmigen Sie bestimmte Befehle im Voraus, um bei jeder Ausführung nicht erneut gefragt zu werden:

```json
{
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test:*)",
      "Bash(git status)",
      "Bash(git add:*)",
      "Bash(git diff:*)"
    ]
  }
}
```

**Syntax der Allow-Regeln**:
- `Bash(command)` — exakte Übereinstimmung des Befehls
- `Bash(prefix:*)` — stimmt mit Befehlen überein, die mit dem angegebenen Präfix beginnen
- `Read(file path)` — Lesen einer bestimmten Datei erlauben
- `Write(file path)` — Schreiben in eine bestimmte Datei erlauben

## Deny-Regeln: Schutz vertraulicher Dateien

Verhindern Sie, dass Claude auf vertrauliche Dateien zugreift oder diese ändert:

```json
{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Write(./.git/**)",
      "Bash(rm -rf:*)"
    ]
  }
}
```

**Syntax der Deny-Regeln**:
- Pfadmuster unterstützen die Platzhalter `*` (eine Ebene) und `**` (mehrere Ebenen)
- Deny-Regeln haben eine **höhere Priorität** als Allow-Regeln

## Allow und Deny gemeinsam verwenden

```json
{
  "permissions": {
    "defaultMode": "acceptEdits",
    "allow": [
      "Bash(npm run *)",
      "Bash(git status)",
      "Bash(git diff)"
    ],
    "deny": [
      "Bash(git push:*)",
      "Bash(rm -rf:*)",
      "Read(./.env*)"
    ]
  }
}
```

## Hierarchie der Konfigurationsdateien

Claude Code fasst Berechtigungskonfigurationen in der folgenden Prioritätsreihenfolge zusammen:

| Priorität | Speicherort | Gültigkeitsbereich |
|----------|----------|-------|
| Höchste | `.claude/settings.local.json` (nicht in Git committet) | Persönliche lokale Überschreibungen |
| Mittlere | `.claude/settings.json` (in Git committet) | Gemeinsame Team-Konfiguration |
| Niedrigste | `~/.claude/settings.json` | Globale Benutzerkonfiguration |

**Tipps zur Team-Zusammenarbeit**:
- Teamweite Allow-/Deny-Regeln in `.claude/settings.json` einfügen und in Git committen
- Persönliche Einstellungen in `.claude/settings.local.json` ablegen und in `.gitignore` aufnehmen

## Bewährte Vorgehensweisen

**1. Vertrauliche Zugangsdaten schützen**
```json
{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./credentials/**)",
      "Read(./.ssh/**)"
    ]
  }
}
```

**2. Konfiguration für Frontend-Projekte**
```json
{
  "permissions": {
    "defaultMode": "acceptEdits",
    "allow": [
      "Bash(npm run dev)",
      "Bash(npm run build)",
      "Bash(npm run test:*)",
      "Bash(npm run lint:*)"
    ]
  }
}
```

**3. CI/CD-Automatisierung**
```json
{
  "permissions": {
    "defaultMode": "bypassPermissions"
  }
}
```

> ⚠️ **Warnung**: Der `bypassPermissions`-Modus überspringt alle Sicherheitsprüfungen. Verwenden Sie ihn nur in vollständig vertrauenswürdigen automatisierten Umgebungen.