Outil bash

L’outil bash permet à Claude d’exécuter des commandes shell dans une session bash persistante, permettant les opérations système, l’exécution de scripts et l’automatisation en ligne de commande.

L’outil bash permet à Claude d’exécuter des commandes shell dans une session bash persistante, permettant les opérations système, l’exécution de scripts et l’automatisation en ligne de commande.

Aperçu

L’outil bash fournit à Claude :

• Session bash persistante qui maintient l’état
• Capacité d’exécuter n’importe quelle commande shell
• Accès aux variables d’environnement et au répertoire de travail
• Capacités de chaînage de commandes et de script

Versions de l’outil

Modèle	Version de l’outil
Modèles Claude 4 et Sonnet 3.7	bash_20250124
Claude Sonnet 3.5 (déprécié)	bash_20241022

Claude Sonnet 3.5 (déprécié) nécessite l’en-tête bêta computer-use-2024-10-22 lors de l’utilisation de l’outil bash.

L’outil bash est généralement disponible dans les modèles Claude 4 et Sonnet 3.7.

Cas d’usage

• Flux de travail de développement : Exécuter des commandes de build, des tests et des outils de développement
• Automatisation système : Exécuter des scripts, gérer des fichiers, automatiser des tâches
• Traitement de données : Traiter des fichiers, exécuter des scripts d’analyse, gérer des jeux de données
• Configuration d’environnement : Installer des packages, configurer des environnements

Démarrage rapide

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": "Lister tous les fichiers Python dans le répertoire courant."}
    ]
)

Comment ça fonctionne

L’outil bash maintient une session persistante :

1. Claude détermine quelle commande exécuter
2. Vous exécutez la commande dans un shell bash
3. Retournez la sortie (stdout et stderr) à Claude
4. L’état de la session persiste entre les commandes (variables d’environnement, répertoire de travail)

Paramètres

Paramètre	Requis	Description
command	Oui*	La commande bash à exécuter
restart	Non	Définir à true pour redémarrer la session bash

*Requis sauf si vous utilisez restart

Exemple d'utilisation

// Exécuter une commande
{
  "command": "ls -la *.py"
}

// Redémarrer la session
{
  "restart": true
}

Exemple : Automatisation multi-étapes

Claude peut chaîner des commandes pour accomplir des tâches complexes :

# Demande de l'utilisateur
"Installer la bibliothèque requests et créer un script Python simple qui récupère une blague depuis une API, puis l'exécuter."

# Utilisations d'outils de Claude :
# 1. Installer le package
{"command": "pip install requests"}

# 2. Créer le script
{"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. Exécuter le script
{"command": "python fetch_joke.py"}

La session maintient l’état entre les commandes, donc les fichiers créés à l’étape 2 sont disponibles à l’étape 3.

---

Implémenter l’outil bash

L’outil bash est implémenté comme un outil sans schéma. Lors de l’utilisation de cet outil, vous n’avez pas besoin de fournir un schéma d’entrée comme avec d’autres outils ; le schéma est intégré dans le modèle de Claude et ne peut pas être modifié.

1. Configurer un environnement bash

   Créer une session bash persistante avec laquelle Claude peut interagir :

   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. Gérer l'exécution des commandes

   Créer une fonction pour exécuter des commandes et capturer la sortie :

   def execute_command(self, command):
       # Envoyer la commande à bash
       self.process.stdin.write(command + '\n')
       self.process.stdin.flush()
       
       # Capturer la sortie avec timeout
       output = self._read_output(timeout=10)
       return output
   

3. Traiter les appels d'outils de Claude

   Extraire et exécuter les commandes des réponses de Claude :

   for content in response.content:
       if content.type == "tool_use" and content.name == "bash":
           if content.input.get("restart"):
               bash_session.restart()
               result = "Session bash redémarrée"
           else:
               command = content.input.get("command")
               result = bash_session.execute_command(command)
           
           # Retourner le résultat à Claude
           tool_result = {
               "type": "tool_result",
               "tool_use_id": content.id,
               "content": result
           }
   

4. Implémenter des mesures de sécurité

   Ajouter validation et restrictions :

   def validate_command(command):
       # Bloquer les commandes dangereuses
       dangerous_patterns = ['rm -rf /', 'format', ':(){:|:&};:']
       for pattern in dangerous_patterns:
           if pattern in command:
               return False, f"La commande contient un motif dangereux : {pattern}"
       
       # Ajouter plus de validation si nécessaire
       return True, None
   

Gérer les erreurs

Lors de l’implémentation de l’outil bash, gérez divers scénarios d’erreur :

Timeout d'exécution de commande

Si une commande prend trop de temps à s’exécuter :

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Erreur : La commande a expiré après 30 secondes",
      "is_error": true
    }
  ]
}

Commande non trouvée

Si une commande n’existe pas :

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "bash: commandeinexistante: commande non trouvée",
      "is_error": true
    }
  ]
}

Permission refusée

S’il y a des problèmes de permission :

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "bash: /root/fichier-sensible: Permission refusée",
      "is_error": true
    }
  ]
}

Suivre les meilleures pratiques d’implémentation

Utiliser des timeouts de commande

Implémenter des timeouts pour éviter les commandes qui se bloquent :

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"La commande a expiré après {timeout} secondes"

Maintenir l'état de session

Garder la session bash persistante pour maintenir les variables d’environnement et le répertoire de travail :

# Les commandes exécutées dans la même session maintiennent l'état
commands = [
    "cd /tmp",
    "echo 'Bonjour' > test.txt",
    "cat test.txt"  # Cela fonctionne car nous sommes toujours dans /tmp
]

Gérer les sorties volumineuses

Tronquer les sorties très volumineuses pour éviter les problèmes de limite de tokens :

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... Sortie tronquée ({len(lines)} lignes au total) ..."
    return output

Enregistrer toutes les commandes

Conserver une piste d’audit des commandes exécutées :

import logging

def log_command(command, output, user_id):
    logging.info(f"L'utilisateur {user_id} a exécuté : {command}")
    logging.info(f"Sortie : {output[:200]}...")  # Enregistrer les 200 premiers caractères

Assainir les sorties

Supprimer les informations sensibles des sorties de commande :

def sanitize_output(output):
    # Supprimer les secrets ou identifiants potentiels
    import re
    # Exemple : Supprimer les identifiants AWS
    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

Sécurité

L’outil bash fournit un accès direct au système. Implémentez ces mesures de sécurité essentielles :

• Exécution dans des environnements isolés (Docker/VM)
• Implémentation de filtrage de commandes et de listes d’autorisation
• Définition de limites de ressources (CPU, mémoire, disque)
• Enregistrement de toutes les commandes exécutées

Recommandations clés

• Utiliser ulimit pour définir des contraintes de ressources
• Filtrer les commandes dangereuses (sudo, rm -rf, etc.)
• Exécuter avec des permissions utilisateur minimales
• Surveiller et enregistrer toute exécution de commande

Tarification

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

Voir tarification d’utilisation d’outils pour les détails complets de tarification.

Modèles courants

Flux de travail de développement

• Exécuter des tests : pytest && coverage report
• Construire des projets : npm install && npm run build
• Opérations Git : git status && git add . && git commit -m "message"

Opérations de fichiers

• Traiter des données : wc -l *.csv && ls -lh *.csv
• Rechercher dans les fichiers : find . -name "*.py" | xargs grep "motif"
• Créer des sauvegardes : tar -czf backup.tar.gz ./data

Tâches système

• Vérifier les ressources : df -h && free -m
• Gestion des processus : ps aux | grep python
• Configuration d’environnement : export PATH=$PATH:/nouveau/chemin && echo $PATH

Limitations

• Pas de commandes interactives : Ne peut pas gérer vim, less, ou les invites de mot de passe
• Pas d’applications GUI : Ligne de commande uniquement
• Portée de session : Persiste dans la conversation, perdue entre les appels API
• Limites de sortie : Les sorties volumineuses peuvent être tronquées
• Pas de streaming : Résultats retournés après achèvement

Combinaison avec d’autres outils

L’outil bash est plus puissant lorsqu’il est combiné avec l’éditeur de texte et d’autres outils.

Prochaines étapes

Aperçu de l'utilisation d'outils

Apprendre l’utilisation d’outils avec Claude

Outil éditeur de texte

Visualiser et éditer des fichiers texte avec Claude