Permissions et Sandbox

Contrôler ce que Claude Code peut faire

Par défaut, Claude Code demande confirmation avant chaque action sensible : exécuter une commande shell, écrire un fichier, appeler un MCP. C'est sûr, mais ça interrompt le flow.

Le système de permissions vous donne un contrôle fin : vous décidez ce qui est autorisé automatiquement, ce qui demande confirmation, et ce qui est interdit. Le sandbox ajoute une couche de protection en isolant les commandes dans un environnement restreint.

Le système de permissions

Les trois niveaux

Syntaxe des wildcards

Les permissions utilisent un système de patterns avec wildcards :

{
  "permissions": {
    "allow": [
      "Read(*)",
      "Write(src/**)",
      "Edit(src/**)",
      "Bash(npm run *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "mcp__github__*"
    ],
    "ask": [
      "Bash(git push *)",
      "Bash(git commit *)",
      "Bash(rm *)",
      "Write(package.json)"
    ],
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(./secrets/**)",
      "Bash(curl *)",
      "Bash(wget *)"
    ]
  }
}

Les patterns disponibles

Les outils concernés : Read, Write, Edit, Bash, mcp__* (tous les MCP).

La commande /permissions

Pour gérer les permissions interactivement pendant une session :

# Voir les permissions actuelles
/permissions

# Ajouter une permission allow
/permissions allow "Bash(npm run *)"

# Ajouter une permission deny
/permissions deny "Read(.env)"

Les changements via /permissions sont sauvegardés dans .claude/settings.local.json (personnel, gitignored).

Le sandbox

Qu'est-ce que le sandbox ?

Le sandbox isole les commandes Bash de Claude Code dans un environnement restreint. Concrètement :

• Accès en lecture seule au système de fichiers (sauf le répertoire de travail)
• Pas d'accès réseau sortant
• Pas d'installation de packages système
• Pas de modification de fichiers en dehors du projet

Activer le sandbox

# Via la commande interactive
/sandbox

# Via settings.json
{
  "sandbox": {
    "enabled": true
  }
}

Sandbox + permissions : le combo

Le sandbox et les permissions sont complémentaires :

• Le sandbox protège au niveau système (isolation)
• Les permissions protègent au niveau outil (contrôle d'accès)

Vous pouvez utiliser les deux ensemble pour un contrôle maximal.

Profils de permissions par contexte

Profil développeur junior

Sécurité maximale, confirmation pour la plupart des actions :

{
  "sandbox": { "enabled": true },
  "permissions": {
    "allow": [
      "Read(*)",
      "Bash(npm run dev)",
      "Bash(npm run lint)",
      "Bash(npm run test)"
    ],
    "ask": [
      "Write(*)",
      "Edit(*)",
      "Bash(git *)"
    ],
    "deny": [
      "Read(.env*)",
      "Bash(rm -rf *)",
      "Bash(git push --force *)",
      "Bash(DROP *)"
    ]
  }
}

Profil développeur senior

Confiance élevée, interruptions minimales :

{
  "sandbox": { "enabled": false },
  "permissions": {
    "allow": [
      "Read(*)",
      "Write(src/**)",
      "Edit(src/**)",
      "Bash(npm run *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "Bash(git add *)",
      "Bash(git commit *)",
      "Bash(npx prettier *)",
      "Bash(npx eslint *)",
      "mcp__*"
    ],
    "ask": [
      "Bash(git push *)",
      "Write(package.json)",
      "Write(*.config.*)",
      "Bash(rm *)"
    ],
    "deny": [
      "Read(.env*)",
      "Read(./secrets/**)",
      "Bash(git push --force *)",
      "Bash(curl * | bash)"
    ]
  }
}

Profil CI/CD

Automatisation totale, pas d'interaction possible :

{
  "sandbox": { "enabled": true },
  "permissions": {
    "allow": [
      "Read(*)",
      "Write(*)",
      "Edit(*)",
      "Bash(npm run *)",
      "Bash(git *)"
    ],
    "deny": [
      "Read(.env*)",
      "Bash(curl *)",
      "Bash(wget *)",
      "Bash(rm -rf /)",
      "Bash(git push --force *)"
    ]
  }
}

Le mode auto (/permissions auto)

Le mode auto utilise un classifieur qui évalue automatiquement le risque de chaque action :

# Activer le mode auto
claude --permission-mode auto

En mode auto, Claude Code classe chaque action en safe (exécution automatique) ou risky (demande confirmation). Vous pouvez ajuster le seuil dans settings.json :

{
  "autoMode": {
    "permissionLevel": "default"
  }
}

Les trois niveaux : conservative (peu d'auto-approve), default (équilibré), permissive (beaucoup d'auto-approve).

Où stocker les permissions

Prochaines étapes

• Settings.json avancé pour la hiérarchie complète de configuration
• Système de Hooks pour automatiser les contrôles de sécurité
• Mode Headless et CI/CD pour l'intégration en pipeline
• Référence CLI pour les flags de sécurité (--sandbox, --permission-mode)