yoloai

# yoloAI

**Exécuteur en bac à sable pour agents de codage IA. Fini la fatigue des autorisations, aucun identifiant dans le bac à sable, aucune modification de votre projet tant que vous ne les approuvez pas.**

[![CI](https://github.com/kstenerud/yoloai/actions/workflows/ci.yml/badge.svg)](https://github.com/kstenerud/yoloai/actions/workflows/ci.yml)
[![Nightly Audit](https://github.com/kstenerud/yoloai/actions/workflows/audit.yml/badge.svg)](https://github.com/kstenerud/yoloai/actions/workflows/audit.yml)
[![Release](https://img.shields.io/github/v/release/kstenerud/yoloai)](https://github.com/kstenerud/yoloai/releases/latest)
[![Go Reference](https://pkg.go.dev/badge/github.com/kstenerud/yoloai.svg)](https://pkg.go.dev/github.com/kstenerud/yoloai)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

Les agents de codage IA donnent le meilleur d'eux-mêmes sans garde-fous, et c'est une bien mauvaise façon de les exécuter sur votre vraie machine. yoloAI offre à l'agent un bac à sable jetable où il peut modifier n'importe quoi et exécuter n'importe quoi, sans surveillance. Votre projet, vos identifiants et votre réseau restent sous votre contrôle. Une fois l'agent terminé, examinez le diff et appliquez ce que vous souhaitez conserver.

```text
Vous                          Bac à sable                    Votre projet
 │                              │                                │
 ├─ yoloai new fix-bug .        ├─ copie du projet dans le bac   │
 │                              │                                │
 ├─ << vos invites >>           ├─ l'agent travaille librement   │
 │                              │  (aucune invite d'autorisation)│
 │                              │                                │
 ├─ yoloai diff fix-bug         ├─ affiche ce qui a changé       │
 │                              │                                │
 ├─ yoloai apply fix-bug        │                                ├─ correctifs appliqués
 │  (vous choisissez lesquels)  │                                │
 │                              │                                │
 ├─ yoloai destroy fix-bug      ├─ détruit le bac à sable        │
```

## Pourquoi ?

Les invites d'autorisation existent parce que les agents font des erreurs. Après la centième approbation/refus, vous arrêtez de les lire, et `--dangerously-skip-permissions` n'est qu'un agent confus loin d'une très mauvaise journée. yoloAI réduit le rayon d'impact jusqu'à ce que les invites deviennent inutiles :

- **Vos fichiers sont en sécurité.** L'agent travaille sur une copie isolée de votre projet. `diff` montre exactement ce qui a changé, `apply` corrige votre vrai projet tout en préservant les commits individuels, et vos originaux ne changent jamais tant que vous n'appliquez pas.
- **Vos secrets sont en sécurité.** Le bac à sable démarre à partir d'un environnement minimal construit localement ; les variables d'environnement de l'hôte restent sur l'hôte. Les identifiants arrivent sous forme de montages de fichiers en lecture seule, jamais de variables d'environnement. Lorsque le courtage d'identifiants s'applique (Claude, Gemini et Codex aujourd'hui, activé par défaut), la clé API reste entièrement côté hôte : un proxy local l'injecte en route vers le fournisseur, de sorte que même un agent entièrement compromis n'a rien à exfiltrer.
- **Votre réseau vous appartient.** `--network-isolated` restreint le trafic sortant aux points de terminaison API de l'agent plus les domaines que vous autorisez. `--network-none` supprime complètement le réseau.
- **Votre machine est isolée.** Choisissez votre niveau de confort, des espaces de noms Linux à gVisor en passant par les VM matérielles.

Consultez [Sécurité](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md#security) pour le modèle complet, y compris les limites honnêtes.

## Installation

### Binaire précompilé (recommandé)

Téléchargez l'archive pour votre plateforme depuis la [dernière version](https://github.com/kstenerud/yoloai/releases/latest), extrayez le binaire `yoloai` et placez-le sur votre `PATH` :

```bash
# Linux x86-64 (remplacez par linux_arm64 / darwin_amd64 / darwin_arm64 selon vos besoins).
# Définissez VERSION sur le tag affiché sur la page de la dernière version liée ci-dessus, sans
# le "v" initial — par ex. VERSION=1.2.3 pour le tag v1.2.3.
VERSION=X.Y.Z
curl -fsSL "https://github.com/kstenerud/yoloai/releases/download/v${VERSION}/yoloai_${VERSION}_linux_amd64.tar.gz" \
  | tar -xz yoloai
sudo install yoloai /usr/local/bin/
```

Chaque archive inclut également les complétions shell, la `LICENSE` et le journal des modifications. Les versions sont signées avec cosign (`checksums.txt`) et portent la provenance de build GitHub (`gh attestation verify yoloai_… --repo kstenerud/yoloai`). Des paquets Debian/RPM sont également joints à chaque version.

### Homebrew (macOS / Linux)

```bash
brew install --cask kstenerud/tap/yoloai
```

### Avec `go install`

```bash
# Dernière version
go install github.com/kstenerud/yoloai/cmd/yoloai@latest

# Dernière version de développement (instable)
go install github.com/kstenerud/yoloai/cmd/yoloai@main
```

Nécessite Go 1.26+. Le binaire est placé dans `$GOPATH/bin` (généralement `~/go/bin`).

### Depuis les sources

```bash
git clone https://github.com/kstenerud/yoloai.git
cd yoloai
git checkout "$(git describe --tags --abbrev=0)"   # tag de la version la plus récente ; ou restez sur main pour la version de développement
make build
sudo install yoloai /usr/local/bin/
```

C'est un binaire Go unique sans dépendances d'exécution au-delà du backend de votre choix. Au premier lancement, yoloAI construit son image de base et crée `~/.yoloai/` (ou le répertoire que vous pointez avec `--data-dir`).

## Démarrage rapide

### Non interactif

```bash
# Authentification (yoloAI détecte automatiquement les identifiants existants)
export ANTHROPIC_API_KEY=sk-ant-...   # Claude Code
export GEMINI_API_KEY=...             # Gemini CLI
# Ou laissez-le simplement détecter votre session déjà authentifiée

# 1. Lancez un bac à sable. L'agent commence à travailler immédiatement lorsque vous fournissez une invite
yoloai new fix-bug ./my-project --prompt "corrigez les tests qui échouent"

# 2. Voyez ce que l'agent a modifié
yoloai diff fix-bug

# 3. Appliquez les bonnes parties à votre vrai projet
yoloai apply fix-bug

# 4. Jetez le bac à sable
yoloai destroy fix-bug
```

### Interactif

```bash
yoloai new exploration ./my-project -a
# Vous êtes dans l'agent, exécuté dans tmux dans le bac à sable.
#   Ctrl-B, D pour détacher.
#   yoloai attach exploration pour vous reconnecter.
```

### Itération

Pour les sessions plus longues, travaillez en boucle : dites à l'agent de faire des commits au fur et à mesure, et exécutez `yoloai apply` depuis un autre terminal chaque fois que vous souhaitez récupérer les commits terminés dans votre vrai projet. Chaque application ne ramène que les nouveaux commits depuis la dernière. Lorsque vous êtes satisfait du résultat, poussez comme d'habitude et détruisez le bac à sable. Consultez le [Guide d'utilisation](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md) pour le flux de travail complet.

## Démo

Création d'un bac à sable, invite de l'agent et application des résultats :

https://github.com/user-attachments/assets/9d6740b4-a34e-4253-82ec-cb0e4c7a8bd9

## Fonctionnalités

**Bac à sable**

- Six backends : Docker, Podman, containerd (Kata), Apple Container, Tart et Seatbelt. Fonctionne sur Linux, macOS et Windows (WSL2).
- Force d'isolation sélectionnable par bac à sable, de runc à gVisor jusqu'aux VM Kata (QEMU ou Firecracker).
- Politique réseau par bac à sable : ouvert, liste blanche ou aucun.
- Environnement minimal dans le bac à sable. Tout ce qui vient de l'hôte est une adhésion explicite (`--env`, `--dir`).
- Limites de ressources (`--cpus`, `--memory`) et redirection de ports (`--port`).
- Copies de répertoires de travail économiques : clones d'arbres entiers sur macOS (APFS `clonefile`), reflinks par fichier sur les systèmes de fichiers Linux qui les prennent en charge (btrfs, XFS). Les systèmes de fichiers sans reflink (ext4) obtiennent une copie classique.
- `.gitignore` respecté : tout ce qui est ignoré n'est **PAS** copié dans le bac à sable (pratique de sécurité pour les identifiants de développement sur disque).

**Identifiants**

- Détecte automatiquement vos connexions d'agent existantes : clés API, identifiants d'abonnement, trousseau macOS.
- Le courtage d'identifiants garde la clé API côté hôte (Claude, Gemini et Codex aujourd'hui) ; les identifiants Aider et OpenCode sont fournis sous forme de montages de fichiers en lecture seule.

**Flux de travail**

- Copie/diff/application avec git exécuté côté bac à sable, afin que les dépôts avec filtres et hooks se comportent correctement.
- Appliquez à votre façon : rejouez les commits (par défaut), réduisez en un seul correctif, exportez des fichiers `.patch`, sélectionnez des commits par référence, ou `--dry-run` d'abord.
- Cycle de vie complet : créer, attacher, arrêter, redémarrer, attendre, cloner, réinitialiser, détruire. L'état de l'agent survit aux arrêts et redémarrages.
- Exécutions uniques sans tête pour scripts et CI : `yoloai run --prompt ... --rm`, avec sortie `--json` sur chaque commande.
- Lorsque l'agent se termine, son volet tmux retombe dans un shell afin que vous puissiez inspecter le bac à sable.

**Intégration**

- Claude Code, Codex, Gemini CLI, Aider et OpenCode intégrés, plus un mode `shell` pour tout le reste.
- VS Code : attachez-vous au conteneur, ou ouvrez un Remote Tunnel depuis l'intérieur du bac à sable (`--vscode-tunnel`).
- MCP dans les deux sens : `yoloai mcp serve` permet à un agent externe de piloter des bacs à sable comme outils ; `yoloai mcp proxy` exécute des serveurs MCP dans un bac à sable.
- Profils : images et valeurs par défaut par projet (Dockerfile + config, avec héritage).
- Extensions : ajoutez vos propres sous-commandes sous forme de scripts shell enveloppés en YAML (`yoloai x`).
- Intégrable : la CLI est une fine couche au-dessus d'une [API Go](https://pkg.go.dev/github.com/kstenerud/yoloai) publique.
- Binaire statique unique. L'état vit dans `~/.yoloai/` (déplaçable avec `--data-dir`).

## Infrastructure prise en charge

### Backends de bac à sable

| Backend    | Hôtes pris en charge          | Dépendances                                                       |
|------------|-------------------------------|--------------------------------------------------------------------|
| docker     | Linux, macOS, Windows (WSL2)  | [Docker Engine](https://docs.docker.com/engine/install), [Docker Desktop](https://docs.docker.com/get-docker) ou [OrbStack](https://orbstack.dev) |
| podman     | Linux, macOS                  | [Podman](https://podman.io/get-started) (`brew install podman` sur macOS) |
| containerd | Linux                         | [Kata Containers](https://katacontainers.io) |
| apple      | macOS (Apple Silicon)         | [Apple Container](https://github.com/apple/container) |
| tart       | macOS (Apple Silicon)         | [Tart](https://github.com/cirruslabs/tart) (`brew install cirruslabs/cli/tart`) |
| seatbelt   | macOS (tous)                  | Aucune (utilise `sandbox-exec` intégré)                           |

**Remarque** : Tart fournit une VM macOS complète, vous permettant d'exécuter des simulateurs dans le bac à sable.

### Modes d'isolation

Mettez éventuellement à niveau le runtime OCI pour une isolation plus forte. Les modes gVisor sont disponibles sur docker et podman ; les modes VM sont fournis avec le backend containerd.

| Mode | Description |
|------|-------------|
| `container` | `runc` par défaut : espaces de noms Linux et cgroups standard |
| `container-enhanced` | Noyau en espace utilisateur (gVisor/runsc) : interception des appels système, pas besoin de KVM |
| `container-privileged` | Toutes les capacités, seccomp/AppArmor non confinés. À utiliser pour Docker-in-Docker et Compose |
| `vm` | Kata Containers (QEMU) : isolation par VM matérielle |
| `vm-enhanced` | Kata + microVM Firecracker : isolation par VM légère |

```bash
# Utilisez gVisor pour tous les nouveaux bacs à sable
yoloai config set isolation container-enhanced

# Ou par bac à sable
yoloai new task . --isolation container-enhanced
```

### Agents

| Mode       | Description |
|------------|-------------|
| `claude`   | Exécute [Claude Code](https://github.com/anthropics/claude-code) via clé API ou identifiants d'abonnement (par défaut) |
| `codex`    | Exécute [Codex](https://github.com/openai/codex) via clé API ou identifiants d'abonnement |
| `gemini`   | Exécute [Gemini CLI](https://github.com/google-gemini/gemini-cli) via clé API ou identifiants d'abonnement |
| `aider`    | Exécute [Aider](https://github.com/Aider-AI/aider) (votre configuration est copiée) |
| `opencode` | Exécute [OpenCode](https://github.com/anomalyco/opencode) (votre configuration est copiée) |
| `shell`    | Exécute un shell tmux avec tous les identifiants d'agent préchargés |
| `idle`     | Exécute un processus inactif pour permettre le proxy MCP |

Utilisez `yoloai system agents` pour lister les agents disponibles.

## En savoir plus

- **[Guide d'utilisation](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md)** : commandes, drapeaux, modes de répertoire de travail, configuration, sécurité
- **[Feuille de route](https://github.com/kstenerud/yoloai/blob/main/docs/ROADMAP.md)** : fonctionnalités à venir
- **[Architecture](https://github.com/kstenerud/yoloai/blob/main/docs/contributors/architecture/README.md)** : navigation dans le code pour les contributeurs

## Statut

Bêta publique. Le flux de travail principal est stable et utilisé quotidiennement ; les interfaces peuvent encore changer entre les versions 0.x, et chaque changement cassant est documenté dans [BREAKING-CHANGES](https://github.com/kstenerud/yoloai/blob/main/docs/BREAKING-CHANGES.md). [Les retours sont les bienvenus.](https://github.com/kstenerud/yoloai/issues)

## Licence

[MIT](https://github.com/kstenerud/yoloai/blob/main/LICENSE)