Cascade Hooks (Beta)

Cascade Hooks ermöglichen es Ihnen, benutzerdefinierte Shell-Befehle an entscheidenden Punkten im Workflow von Cascade auszuführen. Diese leistungsfähige Erweiterungsfunktion erlaubt es, Abläufe zu protokollieren, Leitplanken durchzusetzen, Validierungen durchzuführen oder Integrationen mit externen Systemen herzustellen.

Beta-Version: Cascade Hooks befinden sich derzeit in der Beta-Phase und werden aktiv weiterentwickelt. Funktionen und APIs können sich ändern. Bitte kontaktieren Sie den Windsurf Support mit Feedback oder zur Meldung von Bugs.

Hooks sind für Power-User und Enterprise-Teams konzipiert, die eine fein abgestimmte Kontrolle über das Verhalten von Cascade benötigen. Sie erfordern grundlegende Kenntnisse in Shell-Scripting.

Was Sie bauen können

Hooks erschließen ein breites Spektrum an Automatisierungs- und Governance-Funktionen:

Protokollierung & Analytics: Verfolgen Sie jede gelesene Datei, Codeänderung oder jeden von Cascade ausgeführten Befehl für Compliance- und Nutzungsanalysen
Sicherheitskontrollen: Verhindern Sie, dass Cascade auf sensible Dateien zugreift oder gefährliche Befehle ausführt
Qualitätssicherung: Führen Sie nach Codeänderungen automatisch Linter, Formatter oder Tests aus
Benutzerdefinierte Workflows: Integrieren Sie Issue-Tracker, Benachrichtigungssysteme oder Deployment-Pipelines
Team-Standardisierung: Setzen Sie Coding-Standards und Best Practices in Ihrer Organisation durch

Funktionsweise von Hooks

Hooks sind Shell-Befehle, die automatisch ausgeführt werden, wenn bestimmte Cascade-Aktionen stattfinden. Jeder Hook:

Erhält Kontext (Details zur ausgeführten Aktion) über JSON über die Standardeingabe
Führt Ihr Skript aus – Python, Bash, Node.js oder jede andere ausführbare Datei
Gibt ein Ergebnis zurück über Rückgabecode und Ausgabeströme

Bei Pre-Hooks (vor einer Aktion ausgeführt) kann Ihr Skript die Aktion blockieren, indem es mit dem Rückgabecode 2 beendet wird. Dadurch eignen sich Pre-Hooks ideal zur Umsetzung von Sicherheitsrichtlinien oder Validierungsprüfungen.

Konfiguration

Hooks werden in JSON-Dateien konfiguriert, die auf drei Ebenen abgelegt werden können. Cascade lädt und zusammenführt Hooks aus allen Standorten und bietet Teams so Flexibilität bei der Verteilung und Verwaltung von Hook-Konfigurationen.

Systemebene

Systemweite Hooks eignen sich ideal für unternehmensweite Richtlinien, die auf gemeinsam genutzten Entwicklungsrechnern durchgesetzt werden. Sie können sie beispielsweise verwenden, um Sicherheitsrichtlinien, Compliance-Vorgaben oder verpflichtende Code-Review-Workflows durchzusetzen.

macOS: /Library/Application Support/Windsurf/hooks.json
Linux/WSL: /etc/windsurf/hooks.json
Windows: C:\ProgramData\Windsurf\hooks.json

Benutzerebene

Benutzerebenen-Hooks sind ideal für persönliche Präferenzen und optionale Workflows.

Speicherort: ~/.codeium/windsurf/hooks.json

Auf Workspace-Ebene

Hooks auf Workspace-Ebene ermöglichen Teams, projektspezifische Richtlinien gemeinsam mit ihrem Code unter Versionskontrolle zu halten. Sie können benutzerdefinierte Validierungsregeln, projektspezifische Integrationen oder teambezogene Workflows umfassen.

Speicherort: .windsurf/hooks.json im Workspace-Root

Hooks aus allen drei Speicherorten werden zusammengeführt. Wenn dasselbe Hook-Ereignis an mehreren Speicherorten konfiguriert ist, werden alle Hooks in folgender Reihenfolge ausgeführt: System → Benutzer → Workspace.

Grundstruktur

Hier ein Beispiel für die Grundstruktur der Hooks-Konfiguration:

{
  "hooks": {
    "pre_read_code": [
      {
        "command": "python3 /path/to/your/script.py",
        "show_output": true
      }
    ],
    "post_write_code": [
      {
        "command": "python3 /path/to/another/script.py",
        "show_output": true
      }
    ]
  }
}

Konfigurationsoptionen

Jeder Hook akzeptiert die folgenden Parameter:

Parameter	Typ	Beschreibung
`command`	string	Der auszuführende Shell-Befehl. Kann ein beliebiges gültiges ausführbares Programm mit Argumenten sein.
`show_output`	boolean	Ob die stdout/stderr-Ausgabe des Hooks in der benutzerseitigen Cascade-UI angezeigt wird. Nützlich zum Debuggen.
`working_directory`	string	Optional. Das Verzeichnis, von dem aus der Befehl ausgeführt wird. Standardmäßig das Root Ihres Workspace.

Hook-Ereignisse

Cascade stellt acht Hook-Ereignisse bereit, die die wichtigsten Aktionen im Agent-Workflow abdecken.

Gemeinsame Eingabestruktur

Alle Hooks erhalten ein JSON-Objekt mit den folgenden gemeinsamen Feldern:

Feld	Typ	Beschreibung
`agent_action_name`	string	Der Name des Hook-Ereignisses (z. B. „pre_read_code“, „post_write_code“)
`trajectory_id`	string	Eindeutiger Bezeichner für die gesamte Cascade-Konversation
`execution_id`	string	Eindeutiger Bezeichner für den einzelnen Agenten-Turn
`timestamp`	string	ISO-8601-Zeitstempel, zu dem der Hook ausgelöst wurde
`tool_info`	object	Ereignisspezifische Informationen (variieren je nach Hook-Typ)

In den folgenden Beispielen werden die gemeinsamen Felder der Übersichtlichkeit halber weggelassen. Es gibt acht Haupttypen von Hook-Ereignissen:

pre_read_code

Wird ausgelöst, bevor Cascade eine Code-Datei liest. Dies kann die Aktion blockieren, wenn der Hook mit Exit-Code 2 endet. Anwendungsfälle: Dateizugriff einschränken, Lesevorgänge protokollieren, Berechtigungen prüfen Eingabe-JSON:

{
  "agent_action_name": "pre_read_code",
  "tool_info": {
    "file_path": "/Users/yourname/project/file.py"
  }
}

Der file_path kann ein Verzeichnispfad sein, wenn Cascade ein Verzeichnis rekursiv einliest.

post_read_code

Ausgelöst nachdem Cascade eine Code-Datei erfolgreich gelesen hat. Anwendungsfälle: Erfolgreiche Lesevorgänge protokollieren, Dateizugriffsmuster nachverfolgen Eingabe-JSON:

{
  "agent_action_name": "post_read_code",
  "tool_info": {
    "file_path": "/Users/yourname/project/file.py"
  }
}

Dieser file_path kann ein Verzeichnispfad sein, wenn Cascade ein Verzeichnis rekursiv einliest.

pre_write_code

Wird ausgelöst, bevor Cascade eine Code-Datei schreibt oder ändert. Die Aktion kann blockiert werden, wenn der Hook mit Code 2 beendet wird. Anwendungsfälle: Änderungen an geschützten Dateien verhindern, Dateien vor Änderungen sichern Eingabe-JSON:

{
  "agent_action_name": "pre_write_code",
  "tool_info": {
    "file_path": "/Users/yourname/project/file.py",
    "edits": [
      {
        "old_string": "def old_function():\n    pass",
        "new_string": "def new_function():\n    return True"
      }
    ]
  }
}

post_write_code

Ausgelöst nachdem Cascade eine Code-Datei schreibt oder ändert. Anwendungsfälle: Linter, Formatter oder Tests ausführen; Codeänderungen protokollieren Input JSON:

{
  "agent_action_name": "post_write_code",
  "tool_info": {
    "file_path": "/Users/yourname/project/file.py",
    "edits": [
      {
        "old_string": "import os",
        "new_string": "import os\nimport sys"
      }
    ]
  }
}

pre_run_command

Wird ausgelöst, bevor Cascade einen Terminalbefehl ausführt. Dies kann die Aktion blockieren, wenn der Hook mit dem Code 2 beendet wird. Anwendungsfälle: Gefährliche Befehle blockieren, alle Befehlsausführungen protokollieren, Sicherheitsprüfungen hinzufügen Input JSON:

{
  "agent_action_name": "pre_run_command",
  "tool_info": {
    "command_line": "npm install package-name",
    "cwd": "/Users/yourname/project"
  }
}

post_run_command

Wird nachdem Cascade einen Terminalbefehl ausgeführt hat, ausgelöst. Anwendungsfälle: Befehlsausgaben protokollieren, Folgeaktionen auslösen Eingabe-JSON:

{
  "agent_action_name": "post_run_command",
  "tool_info": {
    "command_line": "npm install package-name",
    "cwd": "/Users/yourname/project"
  }
}

pre_mcp_tool_use

Ausgelöst bevor Cascade ein MCP (Model Context Protocol)‑Tool aufruft. Dies kann die Aktion blockieren, wenn der Hook mit Code 2 beendet wird. Anwendungsfälle: MCP‑Nutzung protokollieren, festlegen, welche MCP‑Tools verwendet werden dürfen Eingabe‑JSON:

{
  "agent_action_name": "pre_mcp_tool_use",
  "tool_info": {
    "mcp_server_name": "github",
    "mcp_tool_arguments": {
      "owner": "code-owner",
      "repo": "my-cool-repo",
      "title": "Fehlerbericht",
      "body": "Fehlerbeschreibung hier"
    },
    "mcp_tool_name": "create_issue"
  }
}

post_mcp_tool_use

Wird ausgelöst, nachdem Cascade erfolgreich ein MCP-Tool aufgerufen hat. Anwendungsfälle: MCP-Vorgänge protokollieren, API-Nutzung nachverfolgen, MCP-Ergebnisse anzeigen Eingabe-JSON:

{
  "agent_action_name": "post_mcp_tool_use",
  "tool_info": {
    "mcp_result": "...",
    "mcp_server_name": "github",
    "mcp_tool_arguments": {
      "owner": "code-owner",
      "perPage": 1,
      "repo": "my-cool-repo",
      "sha": "main"
    },
    "mcp_tool_name": "list_commits"
  }
}

Exit Codes

Ihre Hook-Skripte übermitteln Ergebnisse über Exit Codes:

Exit Code	Bedeutung	Effekt
`0`	Erfolg	Aktion läuft normal weiter
`2`	Blockierender Fehler	Der Cascade-Agent sieht die Fehlermeldung von stderr. Bei Pre-Hooks blockiert dies die Aktion.
Jeder andere	Fehler	Aktion läuft normal weiter

Nur Pre-Hooks (pre_read_code, pre_write_code, pre_run_command, pre_mcp_tool_use) können Aktionen mit Exit Code 2 blockieren. Post-Hooks können nicht blockieren, da die Aktion bereits ausgeführt wurde.

Beachten Sie, dass der Nutzer jede vom Hook erzeugte Standardausgabe und jeden Standardfehler in der Cascade-UI sehen kann, wenn show_output auf true gesetzt ist.

Anwendungsbeispiele

Protokollierung aller Cascade-Aktionen

Protokolliere jede von Cascade ausgeführte Aktion für Audit‑Zwecke. Konfiguration (~/.codeium/windsurf/hooks.json):

{
  "hooks": {
    "post_read_code": [
      {
        "command": "python3 /Users/yourname/hooks/log_input.py",
        "show_output": true
      }
    ],
    "post_write_code": [
      {
        "command": "python3 /Users/yourname/hooks/log_input.py",
        "show_output": true
      }
    ],
    "post_run_command": [
      {
        "command": "python3 /Users/yourname/hooks/log_input.py",
        "show_output": true
      }
    ],
    "post_mcp_tool_use": [
      {
        "command": "python3 /Users/yourname/hooks/log_input.py",
        "show_output": true
      }
    ]
  }
}

Skript (log_input.py):

#!/usr/bin/env python3

import sys
import json

def main():
    # JSON-Daten aus stdin lesen
    input_data = sys.stdin.read()
    
    # JSON parsen
    try:
        data = json.loads(input_data)
        
        # Formatiertes JSON in Datei schreiben
        with open("/Users/yourname/hooks/input.txt", "a") as f:
            f.write('\n' + '='*80 + '\n')
            f.write(json.dumps(data, indent=2, separators=(',', ': ')))
            f.write('\n')
    
        print(json.dumps(data, indent=2))
    except json.JSONDecodeError as e:
        print(f"Fehler beim Parsen von JSON: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

Dieses Skript protokolliert jeden Hook-Aufruf in einer Logdatei und erzeugt so eine Audit-Trail aller Cascade-Aktionen. Sie können die Eingabedaten transformieren oder nach Bedarf benutzerdefinierte Logik ausführen.

Dateizugriff einschränken

Verhindern Sie, dass Cascade Dateien außerhalb eines bestimmten Verzeichnisses liest. Konfiguration (~/.codeium/windsurf/hooks.json):

{
  "hooks": {
    "pre_read_code": [
      {
        "command": "python3 /Users/yourname/hooks/block_read_access.py",
        "show_output": true
      }
    ]
  }
}

Skript (block_read_access.py):

#!/usr/bin/env python3

import sys
import json

ALLOWED_PREFIX = "/Users/yourname/my-project/"

def main():
    # JSON-Daten aus stdin lesen
    input_data = sys.stdin.read()

    # JSON parsen
    try:
        data = json.loads(input_data)

        if data.get("agent_action_name") == "pre_read_code":
            tool_info = data.get("tool_info", {})
            file_path = tool_info.get("file_path", "")
            
            if not file_path.startswith(ALLOWED_PREFIX):
                print(f"Zugriff verweigert: Cascade darf nur Dateien unter {ALLOWED_PREFIX} lesen", file=sys.stderr)
                sys.exit(2)  # Exit-Code 2 blockiert die Aktion
            
            print(f"Zugriff gewährt: {file_path}", file=sys.stdout)

    except json.JSONDecodeError as e:
        print(f"Fehler beim Parsen von JSON: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

Wenn Cascade versucht, eine Datei außerhalb des zulässigen Verzeichnisses zu lesen, verhindert dieser Hook den Vorgang und zeigt eine Fehlermeldung an.

Gefährliche Commands blockieren

Verhindern Sie, dass Cascade potenziell schädliche Commands ausführt. Konfiguration (~/.codeium/windsurf/hooks.json):

{
  "hooks": {
    "pre_run_command": [
      {
        "command": "python3 /Users/yourname/hooks/block_dangerous_commands.py",
        "show_output": true
      }
    ]
  }
}

Skript (block_dangerous_commands.py):

#!/usr/bin/env python3

import sys
import json

DANGEROUS_COMMANDS = ["rm -rf", "sudo rm", "format", "del /f"]

def main():
    # JSON-Daten aus stdin lesen
    input_data = sys.stdin.read()

    # JSON parsen
    try:
        data = json.loads(input_data)

        if data.get("agent_action_name") == "pre_run_command":
            tool_info = data.get("tool_info", {})
            command = tool_info.get("command_line", "")

            for dangerous_cmd in DANGEROUS_COMMANDS:
                if dangerous_cmd in command:
                    print(f"Command blockiert: ‚{dangerous_cmd}' ist aus Sicherheitsgründen nicht erlaubt.", file=sys.stderr)
                    sys.exit(2)  # Exit-Code 2 blockiert den Command
            
            print(f"Command genehmigt: {command}", file=sys.stdout)

    except json.JSONDecodeError as e:
        print(f"Fehler beim Parsen von JSON: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

Dieser Hook prüft Commands auf gefährliche Muster und blockiert sie vor der Ausführung.

Code-Formatter nach Änderungen ausführen

Code-Dateien automatisch formatieren, nachdem Cascade sie bearbeitet hat. Konfig (~/.codeium/windsurf/hooks.json):

{
  "hooks": {
    "post_write_code": [
      {
        "command": "bash /Users/yourname/hooks/format_code.sh",
        "show_output": false
      }
    ]
  }
}

Skript (format_code.sh):

#!/bin/bash

# JSON von stdin lesen
input=$(cat)

# Dateipfad mit jq extrahieren
file_path=$(echo "$input" | jq -r '.tool_info.file_path')

# Formatierung basierend auf Dateierweiterung
if [[ "$file_path" == *.py ]]; then
    black "$file_path" 2>&1
    echo "Python-Datei formatiert: $file_path"
elif [[ "$file_path" == *.js ]] || [[ "$file_path" == *.ts ]]; then
    prettier --write "$file_path" 2>&1
    echo "JS/TS-Datei formatiert: $file_path"
elif [[ "$file_path" == *.go ]]; then
    gofmt -w "$file_path" 2>&1
    echo "Go-Datei formatiert: $file_path"
fi

exit 0

Dieser Hook führt nach jeder Bearbeitung automatisch den passenden Formatter je nach Dateityp aus.

Bewährte Praktiken

Sicherheit

Verwenden Sie Cascade Hooks auf eigenes Risiko: Hooks führen Shell-Befehle automatisch mit den vollen Berechtigungen Ihres Benutzerkontos aus. Für den von Ihnen konfigurierten Code tragen Sie die volle Verantwortung. Schlecht konzipierte oder bösartige Hooks können Dateien verändern, Daten löschen, Anmeldedaten offenlegen oder Ihr System kompromittieren.

Alle Eingaben validieren: Vertrauen Sie niemals dem Eingabe-JSON ohne Validierung, insbesondere bei Dateipfaden und Befehlen.
Absolute Pfade verwenden: Verwenden Sie in Ihren Hook-Konfigurationen stets absolute Pfade, um Mehrdeutigkeiten zu vermeiden.
Sensible Daten schützen: Vermeiden Sie das Protokollieren sensibler Informationen wie API-Schlüssel oder Anmeldedaten.
Berechtigungen überprüfen: Stellen Sie sicher, dass Ihre Hook-Skripte geeignete Dateisystemberechtigungen haben.
Vor der Bereitstellung prüfen: Überprüfen Sie jeden Hook-Befehl und jedes Skript, bevor Sie es Ihrer Konfiguration hinzufügen.
Isoliert testen: Führen Sie Hooks zuerst in einer Testumgebung aus, bevor Sie sie auf Ihrem primären Entwicklungsrechner aktivieren.

Performance-Aspekte

Hooks schnell halten: Langsame Hooks beeinträchtigen die Reaktionsfähigkeit von Cascade. Streben Sie Ausführungszeiten unter 100 ms an.
Asynchrone Vorgänge nutzen: Für nicht blockierende Hooks sollten Protokollierungen asynchron in eine Warteschlange (Queue) oder eine Datenbank erfolgen.
Früh filtern: Prüfen Sie den Aktionstyp gleich zu Beginn Ihres Skripts, um unnötige Verarbeitung zu vermeiden.

Fehlerbehandlung

JSON immer validieren: Verwenden Sie try-catch-Blöcke, um fehlerhafte Eingaben robust zu behandeln.
Fehler korrekt protokollieren: Schreiben Sie Fehler auf stderr, damit sie sichtbar sind, wenn show_output aktiviert ist.
Sicher ausfallen: Wenn Ihr Hook auf einen Fehler stößt, prüfen Sie, ob er die Aktion blockieren oder sie fortsetzen lassen sollte.

Testen Ihrer Hooks

Mit Logging starten: Implementieren Sie zunächst einen einfachen Logging-Hook, um den Datenfluss nachzuvollziehen.
show_output: true verwenden: Aktivieren Sie während der Entwicklung die Ausgabe, um zu sehen, was Ihre Hooks machen.
Blockierverhalten testen: Stellen Sie sicher, dass Exit-Code 2 Aktionen in Pre-Hooks ordnungsgemäß blockiert.
Alle Codepfade prüfen: Testen Sie sowohl Erfolgs- als auch Fehlerfälle in Ihren Skripten.

Enterprise-Verteilung

Enterprise-Organisationen müssen Sicherheitsrichtlinien, Compliance-Anforderungen und Entwicklungsstandards durchsetzen, die von einzelnen Nutzern nicht umgangen werden können. Cascade Hooks unterstützt dies durch eine systemweite Konfiguration, die Vorrang hat und von Endnutzern ohne Root-Rechte nicht deaktiviert werden kann. Stellen Sie Ihre verpflichtende hooks.json-Konfiguration an diesen betriebssystemspezifischen Speicherorten bereit: macOS:

/Library/Application Support/Windsurf/hooks.json

Linux/WSL:

/etc/windsurf/hooks.json

Windows:

C:\ProgramData\Windsurf\hooks.json

Legen Sie Ihre Hook-Skripte in ein entsprechendes Systemverzeichnis (z. B. /usr/local/share/windsurf-hooks/ auf Unix-Systemen).

Bereitstellungsmethoden

Enterprise-IT-Teams können systemweite Hooks mit Standardtools und -Workflows bereitstellen: Mobile Device Management (MDM)

Jamf Pro (macOS) - Bereitstellung über Konfigurationsprofile oder Skripte
Microsoft Intune (Windows/macOS) - per PowerShell-Skripten oder Richtlinienbereitstellung
Workspace ONE, Google Endpoint Management und andere MDM-Lösungen

Konfigurationsmanagement

Ansible, Puppet, Chef, SaltStack - Nutzen Sie Ihre bestehende Infrastrukturautomatisierung
Benutzerdefinierte Bereitstellungsskripte - Shell-Skripte, PowerShell oder Ihre bevorzugten Tools

Verifizierung und Auditing

Nach der Bereitstellung prüfen, ob Hooks korrekt installiert sind und nicht umgangen werden können:

# Überprüfen, ob System-Hooks vorhanden sind
ls -la /etc/windsurf/hooks.json  # Linux
ls -la "/Library/Application Support/Windsurf/hooks.json"  # macOS

# Hook-Ausführung testen (Hook-Ausgabe sollte in Cascade sichtbar sein)
# Einen Entwickler die entsprechende Cascade-Aktion auslösen lassen

# Überprüfen, dass Benutzer System-Hooks nicht ändern können
sudo chown root:root /etc/windsurf/hooks.json
sudo chmod 644 /etc/windsurf/hooks.json

Wichtig: Systemweite Hooks werden vollständig von Ihrem IT- oder Sicherheitsteam verwaltet. Windsurf installiert oder verwaltet keine Dateien in systemweiten Pfaden. Stellen Sie sicher, dass Ihre internen Teams Bereitstellung, Updates und Compliance gemäß den Richtlinien Ihrer Organisation übernehmen.

Workspace-Hooks für Teamprojekte

Für projektspezifische Konventionen können Teams Hooks auf Workspace-Ebene in der Versionsverwaltung verwenden:

# Zu Ihrem Repository hinzufügen
.windsurf/
├── hooks.json
└── scripts/
    └── format-check.py

# In Git committen
git add .windsurf/
git commit -m "Workspace-Hooks für Code-Formatierung hinzufügen"

So können Teams ihre Entwicklungspraktiken standardisieren. Achten Sie darauf, sicherheitskritische Richtlinien auf Systemebene zu belassen, und checken Sie auf keinen Fall sensible Informationen in die Versionsverwaltung ein.

Zusätzliche Ressourcen

MCP-Integration: Erfahren Sie mehr über das Model Context Protocol in Windsurf
Workflows: Entdecken Sie, wie Sie Hooks mit Cascade Workflows kombinieren
Analytics: Verfolgen Sie die Nutzung von Cascade mit den Team Analytics

Editor

Cascade

Konten

Kontextbewusstsein

Fehlerbehebung

Sicherheit

​Was Sie bauen können

​Funktionsweise von Hooks

​Konfiguration

​Systemebene

​Benutzerebene

​Auf Workspace-Ebene

​Grundstruktur

​Konfigurationsoptionen

​Hook-Ereignisse

​Gemeinsame Eingabestruktur

​pre_read_code

​post_read_code

​pre_write_code

​post_write_code

​pre_run_command

​post_run_command

​pre_mcp_tool_use

​post_mcp_tool_use

​Exit Codes

​Anwendungsbeispiele

​Protokollierung aller Cascade-Aktionen

​Dateizugriff einschränken

​Gefährliche Commands blockieren

​Code-Formatter nach Änderungen ausführen

​Bewährte Praktiken

​Sicherheit

​Performance-Aspekte

​Fehlerbehandlung

​Testen Ihrer Hooks

​Enterprise-Verteilung

​Bereitstellungsmethoden

​Verifizierung und Auditing

​Workspace-Hooks für Teamprojekte

​Zusätzliche Ressourcen

Was Sie bauen können

Funktionsweise von Hooks

Konfiguration

Systemebene

Benutzerebene

Auf Workspace-Ebene

Grundstruktur

Konfigurationsoptionen

Hook-Ereignisse

Gemeinsame Eingabestruktur

pre_read_code

post_read_code

pre_write_code

post_write_code

pre_run_command

post_run_command

pre_mcp_tool_use

post_mcp_tool_use

Exit Codes

Anwendungsbeispiele

Protokollierung aller Cascade-Aktionen

Dateizugriff einschränken

Gefährliche Commands blockieren

Code-Formatter nach Änderungen ausführen

Bewährte Praktiken

Sicherheit

Performance-Aspekte

Fehlerbehandlung

Testen Ihrer Hooks

Enterprise-Verteilung

Bereitstellungsmethoden

Verifizierung und Auditing

Workspace-Hooks für Teamprojekte

Zusätzliche Ressourcen