fencesandbox/fenceSandbox léger, sans conteneur, pour exécuter des commandes avec des restrictions réseau et de système de fichiers.
<div align="center">
[](https://github.com/fencesandbox/fence/actions/workflows/main.yml)
[](https://fencesandbox.com/docs)
[](https://deepwiki.com/fencesandbox/fence)
[](https://opensource.org/licenses/Apache-2.0)
</div>
Fence encapsule les commandes dans un bac à sable qui bloque l'accès réseau par défaut et restreint les opérations sur le système de fichiers en fonction de règles configurables. Il est très utile pour exécuter du code semi‑fiable (installations de paquets, scripts de build, jobs CI, dépôts inconnus) avec des effets de bord contrôlés, et peut également compléter les agents de codage IA comme défense en profondeur.
```bash
# Bloquer tout accès réseau (par défaut)
fence curl https://example.com # → 403 Interdit
# Autoriser des domaines spécifiques
fence -t code npm install # → utilise le modèle 'code' qui autorise npm/pypi/etc.
# Bloquer les commandes dangereuses
fence -c "rm -rf /" # → bloqué par les règles d'interdiction de commandes
```
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/11239/fcd1fc039e748ec60455ad0f3f2cba244840824dc0d96362d18fd29500e46206.gif" alt="Démonstration de Fence avec Claude Code" width="800">
</p>
Fence est aussi un gestionnaire de permissions pour vos agents CLI. **Fonctionne avec les agents de codage populaires comme Claude Code, Codex, Amp, Gemini CLI, GitHub Copilot, OpenCode, Factory (Droid) CLI et bien d'autres** – voir [agents.md](https://github.com/fencesandbox/fence/blob/main/docs/agents.md).
## Installer
> [!NOTE]
> Fence a été déplacé de `github.com/Use-Tusk/fence` vers `github.com/fencesandbox/fence`.
> Si vous avez installé avec Homebrew depuis l'ancien dépôt Tusk, basculez vers le nouveau dépôt :
>
> ```bash
> brew uninstall use-tusk/tap/fence
> brew untap use-tusk/tap
> brew tap fencesandbox/tap
> brew install fencesandbox/tap/fence
> ```
>
> Si vous avez installé avec `go install`, réinstallez depuis le nouveau module :
>
> ```bash
> go install github.com/fencesandbox/fence/cmd/fence@latest
> ```
**macOS / Linux :**
```bash
curl -fsSL https://cli.fencesandbox.com/install.sh | sh
```
**Homebrew (macOS) :**
```bash
brew tap fencesandbox/tap
brew install fencesandbox/tap/fence
```
**Nix (macOS, Linux, Windows (WSL)) :**
```sh
nix run nixpkgs#fence -- --help
```
Cette commande exécute Fence directement depuis le dépôt, sans l'installer. Pour l'installer, suivez les instructions [de NixOS](https://nix.dev) ou [nix-darwin](https://github.com/nix-darwin/nix-darwin).
<details>
<summary>Autres méthodes d'installation</summary>
**Go install :**
```bash
go install github.com/fencesandbox/fence/cmd/fence@latest
```
**Compiler depuis les sources :**
```bash
git clone https://github.com/fencesandbox/fence
cd fence
go build -o fence ./cmd/fence
```
</details>
**Prérequis supplémentaires pour Linux :**
- `bubblewrap` (pour le bac à sable)
- `socat` (pour le pont réseau)
- `bpftrace` (optionnel, pour la visibilité des violations du système de fichiers lors de la surveillance avec `-m`)
## Utilisation
### De base
```bash
# Exécuter une commande avec tout le réseau bloqué (aucun domaine autorisé par défaut)
fence curl https://example.com
# Exécuter avec expansion du shell
fence -c "echo hello && ls"
# Activer les logs de débogage
fence -d curl https://example.com
# Utiliser un modèle
fence -t code -- claude # Exécute Claude Code avec la configuration du modèle `code`
# Mode surveillance (affiche les violations)
fence -m npm install
# Envoyer les logs de surveillance/débogage de Fence vers un fichier
fence -m --fence-log-file /tmp/fence.log -- claude
tail -f /tmp/fence.log
# Inspecter la chaîne d'héritage de la configuration et la configuration active fusionnée
fence config show
# Afficher toutes les commandes et options
fence --help
```
> [!TIP]
> Besoin de passer des options à la commande que vous exécutez ? Utilisez `--` pour séparer les options de Fence des options de la commande, par exemple :
>
> ```bash
> fence -- claude --dangerously-skip-permissions
> ```
### Configuration
Lorsque `--settings` n'est pas fourni, Fence cherche d'abord `fence.jsonc` (ou `fence.json`) dans le répertoire courant et les répertoires parents. Si aucun n'est trouvé, il utilise `~/.config/fence/fence.{jsonc,json}` par défaut. Les deux extensions sont traitées comme du JSONC (les commentaires et les virgules finales sont autorisés). Voir la [référence de configuration](https://github.com/fencesandbox/fence/blob/main/docs/configuration.md) pour plus de détails.
```json
{
"$schema": "https://raw.githubusercontent.com/fencesandbox/fence/main/docs/schema/fence.schema.json",
"extends": "code",
"network": { "allowedDomains": ["private.company.com"] },
"filesystem": { "allowWrite": ["."] },
"command": { "deny": ["git push", "npm publish"] }
}
```
Pour des surcharges locales à un dépôt au‑dessus de la configuration normale de chaque utilisateur, utilisez :
```json
{
"extends": "@base",
"filesystem": { "allowWrite": ["."] }
}
```
Utilisez `fence --settings ./custom.json` pour spécifier une configuration différente.
Inspectez la configuration active sans exécuter de commande :
```bash
fence config show
fence config show --settings ./custom.json
fence config show --template code
```
`fence config show` affiche la chaîne de configuration sur `stderr` et la configuration entièrement résolue en JSON brut sur `stdout`, afin que vous puissiez rediriger le JSON vers des outils comme `jq`.
Créez une configuration de démarrage avec des valeurs par défaut raisonnables :
```bash
# Crée une configuration au chemin par défaut avec :
# { "extends": "code" }
fence config init
# Inclut des tableaux d'échafaudage comme indications modifiables
fence config init --scaffold
```
### Importer depuis Claude Code
```bash
fence import --claude --save
```
## Fonctionnalités
- **Isolement réseau** – Tout le trafic sortant bloqué par défaut ; liste blanche de domaines via la configuration
- **Restrictions du système de fichiers** – Contrôle des chemins d'accès en lecture/écriture
- **Blocage de commandes** – Interdire les commandes dangereuses comme `rm -rf /`, `git push`
- **Filtrage des commandes SSH** – Contrôle des hôtes et des commandes autorisés via SSH
- **Modèles intégrés** – Ensembles de règles préconfigurés pour les flux de travail courants
- **Surveillance des violations** – Journalisation en temps réel des requêtes bloquées (`-m`)
- **Multi‑plateforme** – macOS (sandbox-exec) + Linux (bubblewrap)
Fence peut être utilisé comme paquet Go ou outil CLI.
## Documentation
La documentation complète est hébergée sur **[fencesandbox.com/docs](https://fencesandbox.com/docs)**.
Liens rapides :
- [Démarrage rapide](https://fencesandbox.com/docs/quickstart) ([source](https://github.com/fencesandbox/fence/blob/main/docs/quickstart.md))
- [Référence de configuration](https://fencesandbox.com/docs/reference/configuration) ([source](https://github.com/fencesandbox/fence/blob/main/docs/configuration.md))
- [Hooks d'agent](https://fencesandbox.com/docs/guides/hooks) ([source](https://github.com/fencesandbox/fence/blob/main/docs/hooks.md))
- [Modèle de sécurité](https://fencesandbox.com/docs/reference/security-model) ([source](https://github.com/fencesandbox/fence/blob/main/docs/security-model.md))
- [Utilisation en tant que bibliothèque Go](https://fencesandbox.com/docs/reference/library) ([source](https://github.com/fencesandbox/fence/blob/main/docs/library.md))
- [Architecture](https://fencesandbox.com/docs/reference/architecture) ([source](https://github.com/fencesandbox/fence/blob/main/ARCHITECTURE.md))
## Attribution
Inspiré par le [sandbox-runtime](https://github.com/anthropic-experimental/sandbox-runtime) d'Anthropic.