Bash-Tool

Das Bash-Tool ermöglicht es Claude, Shell-Befehle in einer persistenten Bash-Sitzung auszuführen und dabei Systemoperationen, Skriptausführung und Kommandozeilen-Automatisierung zu ermöglichen.

Das Bash-Tool ermöglicht es Claude, Shell-Befehle in einer persistenten Bash-Sitzung auszuführen und dabei Systemoperationen, Skriptausführung und Kommandozeilen-Automatisierung zu ermöglichen.

Überblick

Das Bash-Tool bietet Claude:

• Persistente Bash-Sitzung, die den Zustand beibehält
• Fähigkeit, jeden Shell-Befehl auszuführen
• Zugriff auf Umgebungsvariablen und Arbeitsverzeichnis
• Befehlsverkettung und Skriptfähigkeiten

Tool-Versionen

Modell	Tool-Version
Claude 4 Modelle und Sonnet 3.7	bash_20250124
Claude Sonnet 3.5 (veraltet)	bash_20241022

Claude Sonnet 3.5 (veraltet) erfordert den computer-use-2024-10-22 Beta-Header bei der Verwendung des Bash-Tools.

Das Bash-Tool ist allgemein verfügbar in Claude 4 Modellen und Sonnet 3.7.

Anwendungsfälle

• Entwicklungsworkflows: Build-Befehle, Tests und Entwicklungstools ausführen
• Systemautomatisierung: Skripte ausführen, Dateien verwalten, Aufgaben automatisieren
• Datenverarbeitung: Dateien verarbeiten, Analyseskripte ausführen, Datensätze verwalten
• Umgebungseinrichtung: Pakete installieren, Umgebungen konfigurieren

Schnellstart

Python

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "bash_20250124",
            "name": "bash"
        }
    ],
    messages=[
        {"role": "user", "content": "Liste alle Python-Dateien im aktuellen Verzeichnis auf."}
    ]
)

Funktionsweise

Das Bash-Tool behält eine persistente Sitzung bei:

1. Claude bestimmt, welcher Befehl ausgeführt werden soll
2. Sie führen den Befehl in einer Bash-Shell aus
3. Geben Sie die Ausgabe (stdout und stderr) an Claude zurück
4. Der Sitzungszustand bleibt zwischen Befehlen bestehen (Umgebungsvariablen, Arbeitsverzeichnis)

Parameter

Parameter	Erforderlich	Beschreibung
command	Ja*	Der auszuführende Bash-Befehl
restart	Nein	Auf true setzen, um die Bash-Sitzung neu zu starten

*Erforderlich, außer bei Verwendung von restart

Beispielverwendung

// Einen Befehl ausführen
{
  "command": "ls -la *.py"
}

// Die Sitzung neu starten
{
  "restart": true
}

Beispiel: Mehrstufige Automatisierung

Claude kann Befehle verketten, um komplexe Aufgaben zu erledigen:

# Benutzeranfrage
"Installiere die requests-Bibliothek und erstelle ein einfaches Python-Skript, das einen Witz von einer API abruft, dann führe es aus."

# Claudes Tool-Verwendungen:
# 1. Paket installieren
{"command": "pip install requests"}

# 2. Skript erstellen
{"command": "cat > fetch_joke.py << 'EOF'\nimport requests\nresponse = requests.get('https://official-joke-api.appspot.com/random_joke')\njoke = response.json()\nprint(f\"Setup: {joke['setup']}\")\nprint(f\"Punchline: {joke['punchline']}\")\nEOF"}

# 3. Skript ausführen
{"command": "python fetch_joke.py"}

Die Sitzung behält den Zustand zwischen Befehlen bei, sodass in Schritt 2 erstellte Dateien in Schritt 3 verfügbar sind.

---

Das Bash-Tool implementieren

Das Bash-Tool wird als schemaloses Tool implementiert. Bei der Verwendung dieses Tools müssen Sie kein Eingabeschema bereitstellen wie bei anderen Tools; das Schema ist in Claudes Modell eingebaut und kann nicht geändert werden.

1. Eine Bash-Umgebung einrichten

   Erstellen Sie eine persistente Bash-Sitzung, mit der Claude interagieren kann:

   import subprocess
   import threading
   import queue
   
   class BashSession:
       def __init__(self):
           self.process = subprocess.Popen(
               ['/bin/bash'],
               stdin=subprocess.PIPE,
               stdout=subprocess.PIPE,
               stderr=subprocess.PIPE,
               text=True,
               bufsize=0
           )
           self.output_queue = queue.Queue()
           self.error_queue = queue.Queue()
           self._start_readers()
   

2. Befehlsausführung handhaben

   Erstellen Sie eine Funktion zur Ausführung von Befehlen und Erfassung der Ausgabe:

   def execute_command(self, command):
       # Befehl an Bash senden
       self.process.stdin.write(command + '\n')
       self.process.stdin.flush()
       
       # Ausgabe mit Timeout erfassen
       output = self._read_output(timeout=10)
       return output
   

3. Claudes Tool-Aufrufe verarbeiten

   Befehle aus Claudes Antworten extrahieren und ausführen:

   for content in response.content:
       if content.type == "tool_use" and content.name == "bash":
           if content.input.get("restart"):
               bash_session.restart()
               result = "Bash-Sitzung neu gestartet"
           else:
               command = content.input.get("command")
               result = bash_session.execute_command(command)
           
           # Ergebnis an Claude zurückgeben
           tool_result = {
               "type": "tool_result",
               "tool_use_id": content.id,
               "content": result
           }
   

4. Sicherheitsmaßnahmen implementieren

   Validierung und Einschränkungen hinzufügen:

   def validate_command(command):
       # Gefährliche Befehle blockieren
       dangerous_patterns = ['rm -rf /', 'format', ':(){:|:&};:']
       for pattern in dangerous_patterns:
           if pattern in command:
               return False, f"Befehl enthält gefährliches Muster: {pattern}"
       
       # Nach Bedarf weitere Validierung hinzufügen
       return True, None
   

Fehler behandeln

Bei der Implementierung des Bash-Tools sollten verschiedene Fehlerszenarien behandelt werden:

Timeout bei Befehlsausführung

Wenn ein Befehl zu lange dauert:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Fehler: Befehl nach 30 Sekunden abgebrochen",
      "is_error": true
    }
  ]
}

Befehl nicht gefunden

Wenn ein Befehl nicht existiert:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "bash: nichtexistierenderbefehl: Befehl nicht gefunden",
      "is_error": true
    }
  ]
}

Berechtigung verweigert

Bei Berechtigungsproblemen:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "bash: /root/sensitive-file: Berechtigung verweigert",
      "is_error": true
    }
  ]
}

Bewährte Implementierungspraktiken befolgen

Befehlstimeouts verwenden

Timeouts implementieren, um hängende Befehle zu verhindern:

def execute_with_timeout(command, timeout=30):
    try:
        result = subprocess.run(
            command, 
            shell=True, 
            capture_output=True, 
            text=True, 
            timeout=timeout
        )
        return result.stdout + result.stderr
    except subprocess.TimeoutExpired:
        return f"Befehl nach {timeout} Sekunden abgebrochen"

Sitzungszustand beibehalten

Die Bash-Sitzung persistent halten, um Umgebungsvariablen und Arbeitsverzeichnis beizubehalten:

# Befehle, die in derselben Sitzung ausgeführt werden, behalten den Zustand bei
commands = [
    "cd /tmp",
    "echo 'Hallo' > test.txt",
    "cat test.txt"  # Das funktioniert, weil wir noch in /tmp sind
]

Große Ausgaben handhaben

Sehr große Ausgaben kürzen, um Token-Limit-Probleme zu vermeiden:

def truncate_output(output, max_lines=100):
    lines = output.split('\n')
    if len(lines) > max_lines:
        truncated = '\n'.join(lines[:max_lines])
        return f"{truncated}\n\n... Ausgabe gekürzt ({len(lines)} Zeilen insgesamt) ..."
    return output

Alle Befehle protokollieren

Ein Audit-Trail der ausgeführten Befehle führen:

import logging

def log_command(command, output, user_id):
    logging.info(f"Benutzer {user_id} ausgeführt: {command}")
    logging.info(f"Ausgabe: {output[:200]}...")  # Erste 200 Zeichen protokollieren

Ausgaben bereinigen

Sensible Informationen aus Befehlsausgaben entfernen:

def sanitize_output(output):
    # Potenzielle Geheimnisse oder Anmeldedaten entfernen
    import re
    # Beispiel: AWS-Anmeldedaten entfernen
    output = re.sub(r'aws_access_key_id\s*=\s*\S+', 'aws_access_key_id=***', output)
    output = re.sub(r'aws_secret_access_key\s*=\s*\S+', 'aws_secret_access_key=***', output)
    return output

Sicherheit

Das Bash-Tool bietet direkten Systemzugriff. Implementieren Sie diese wesentlichen Sicherheitsmaßnahmen:

• Ausführung in isolierten Umgebungen (Docker/VM)
• Implementierung von Befehlsfilterung und Allowlists
• Festlegung von Ressourcenlimits (CPU, Speicher, Festplatte)
• Protokollierung aller ausgeführten Befehle

Wichtige Empfehlungen

• ulimit verwenden, um Ressourcenbeschränkungen festzulegen
• Gefährliche Befehle filtern (sudo, rm -rf, etc.)
• Mit minimalen Benutzerberechtigungen ausführen
• Alle Befehlsausführungen überwachen und protokollieren

Preise

The bash tool adds 245 input tokens to your API calls.

Additional tokens are consumed by:

• Command outputs (stdout/stderr)
• Error messages
• Large file contents

Siehe Tool-Verwendungspreise für vollständige Preisdetails.

Häufige Muster

Entwicklungsworkflows

• Tests ausführen: pytest && coverage report
• Projekte erstellen: npm install && npm run build
• Git-Operationen: git status && git add . && git commit -m "message"

Dateioperationen

• Daten verarbeiten: wc -l *.csv && ls -lh *.csv
• Dateien durchsuchen: find . -name "*.py" | xargs grep "pattern"
• Backups erstellen: tar -czf backup.tar.gz ./data

Systemaufgaben

• Ressourcen prüfen: df -h && free -m
• Prozessverwaltung: ps aux | grep python
• Umgebungseinrichtung: export PATH=$PATH:/new/path && echo $PATH

Einschränkungen

• Keine interaktiven Befehle: Kann vim, less oder Passwort-Eingabeaufforderungen nicht handhaben
• Keine GUI-Anwendungen: Nur Kommandozeile
• Sitzungsbereich: Bleibt innerhalb der Unterhaltung bestehen, geht zwischen API-Aufrufen verloren
• Ausgabenlimits: Große Ausgaben können gekürzt werden
• Kein Streaming: Ergebnisse werden nach Abschluss zurückgegeben

Kombination mit anderen Tools

Das Bash-Tool ist am mächtigsten, wenn es mit dem Texteditor und anderen Tools kombiniert wird.

Nächste Schritte

Tool-Verwendungsübersicht

Erfahren Sie mehr über die Tool-Verwendung mit Claude

Texteditor-Tool

Textdateien mit Claude anzeigen und bearbeiten