yoloai

# yoloAI

**Sandbox-Ausführungsumgebung für KI-Codierungsagenten. Keine Berechtigungsmüdigkeit, keine Anmeldedaten in der Sandbox, keine Änderungen an deinem Projekt, bis du sie genehmigst.**

[![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)

KI-Codierungsagenten funktionieren am besten ohne Sicherheitsvorkehrungen, und das ist eine schlechte Art, sie auf deinem echten Rechner auszuführen. yoloAI gibt dem Agenten eine Wegwerf-Sandbox, in der er alles bearbeiten und alles ausführen kann, unbeaufsichtigt. Dein Projekt, deine Anmeldedaten und dein Netzwerk bleiben unter deiner Kontrolle. Wenn der Agent fertig ist, überprüfe den Diff und übernimm, was du behalten möchtest.

```text
Du                          Sandbox                        Dein Projekt
 │                              │                                │
 ├─ yoloai new fix-bug .        ├─ Sandbox-Kopie des Projekts    │
 │                              │                                │
 ├─ << deine Eingabeaufforderung(en) >>  ├─ Agent arbeitet frei  │
 │                              │  (keine Berechtigungsabfragen) │
 │                              │                                │
 ├─ yoloai diff fix-bug         ├─ zeigt, was sich geändert hat  │
 │                              │                                │
 ├─ yoloai apply fix-bug        │                                ├─ Patches angewendet
 │  (du wählst aus, welche)     │                                │
 │                              │                                │
 ├─ yoloai destroy fix-bug      ├─ zerstört die Sandbox          │
```

## Warum?

Berechtigungsabfragen existieren, weil Agenten Fehler machen. Nach der hundertsten Genehmigen/Ablehnen-Abfrage liest du sie nicht mehr, und `--dangerously-skip-permissions` ist nur einen verwirrten Agenten von einem sehr schlechten Tag entfernt. yoloAI verkleinert den Schadensradius, bis die Abfragen unnötig sind:

- **Deine Dateien sind sicher.** Der Agent arbeitet an einer isolierten Kopie deines Projekts. `diff` zeigt genau, was sich geändert hat, `apply` patcht dein echtes Projekt unter Beibehaltung einzelner Commits, und deine Originale ändern sich nie, bis du sie anwendest.
- **Deine Geheimnisse sind sicher.** Die Sandbox startet aus einer minimalen, lokal erstellten Umgebung; Host-Umgebungsvariablen bleiben auf dem Host. Anmeldedaten kommen als schreibgeschützte Datei-Mounts, niemals als Umgebungsvariablen. Wo Credential-Brokering gilt (Claude, Gemini und Codex heute, standardmäßig aktiviert), bleibt der API-Schlüssel vollständig host-seitig: Ein lokaler Proxy injiziert ihn auf dem Weg zum Anbieter, sodass selbst ein vollständig kompromittierter Agent nichts exfiltrieren kann.
- **Dein Netzwerk gehört dir.** `--network-isolated` beschränkt den ausgehenden Datenverkehr auf die API-Endpunkte des Agenten plus von dir erlaubte Domains. `--network-none` entfernt das Netzwerk vollständig.
- **Dein Rechner ist isoliert.** Wähle dein Komfortniveau, von Linux-Namespaces über gVisor bis hin zu Hardware-VMs.

Siehe [Sicherheit](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md#security) für das vollständige Modell, einschließlich ehrlicher Einschränkungen.

## Installation

### Vorgefertigtes Binärpaket (empfohlen)

Lade das Archiv für deine Plattform vom [neuesten Release](https://github.com/kstenerud/yoloai/releases/latest) herunter, extrahiere die `yoloai`-Binärdatei und lege sie auf deinen `PATH`:

```bash
# Linux x86-64 (ersetze bei Bedarf durch linux_arm64 / darwin_amd64 / darwin_arm64).
# Setze VERSION auf das Tag, das auf der oben verlinkten Release-Seite angezeigt wird, ohne
# das führende "v" — z. B. VERSION=1.2.3 für 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/
```

Jedes Archiv enthält außerdem Shell-Vervollständigungen, die `LICENSE` und das Änderungsprotokoll. Releases sind mit cosign signiert (`checksums.txt`) und tragen GitHub-Build-Herkunftsnachweise (`gh attestation verify yoloai_… --repo kstenerud/yoloai`). Debian/RPM-Pakete sind ebenfalls jedem Release beigefügt.

### Homebrew (macOS / Linux)

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

### Mit `go install`

```bash
# Neuestes Release
go install github.com/kstenerud/yoloai/cmd/yoloai@latest

# Neueste Entwicklungsversion (instabil)
go install github.com/kstenerud/yoloai/cmd/yoloai@main
```

Erfordert Go 1.26+. Die Binärdatei wird in `$GOPATH/bin` platziert (normalerweise `~/go/bin`).

### Aus dem Quellcode

```bash
git clone https://github.com/kstenerud/yoloai.git
cd yoloai
git checkout "$(git describe --tags --abbrev=0)"   # neuestes Release-Tag; oder auf main bleiben für die Entwicklungsversion
make build
sudo install yoloai /usr/local/bin/
```

Es ist eine einzelne Go-Binärdatei ohne Laufzeitabhängigkeiten außer deinem gewählten Backend. Beim ersten Start erstellt yoloAI sein Basis-Image und erstellt `~/.yoloai/` (oder das Verzeichnis, das du mit `--data-dir` angibst).

## Schnellstart

### Nicht-interaktiv

```bash
# Authentifizieren (yoloAI erkennt vorhandene Anmeldedaten automatisch)
export ANTHROPIC_API_KEY=sk-ant-...   # Claude Code
export GEMINI_API_KEY=...             # Gemini CLI
# Oder lass es einfach deine bereits authentifizierte Sitzung übernehmen

# 1. Sandbox starten. Der Agent beginnt sofort zu arbeiten, wenn du eine Eingabeaufforderung angibst
yoloai new fix-bug ./my-project --prompt "fix the failing tests"

# 2. Sehen, was der Agent geändert hat
yoloai diff fix-bug

# 3. Die guten Teile auf dein echtes Projekt anwenden
yoloai apply fix-bug

# 4. Sandbox verwerfen
yoloai destroy fix-bug
```

### Interaktiv

```bash
yoloai new exploration ./my-project -a
# Du bist im Agenten, der in tmux in der Sandbox läuft.
#   Strg-B, D zum Trennen.
#   yoloai attach exploration zum erneuten Verbinden.
```

### Iterieren

Für längere Sitzungen arbeite in einer Schleife: Sage dem Agenten, er soll während der Arbeit committen, und führe `yoloai apply` von einem anderen Terminal aus, wann immer du die fertigen Commits in dein echtes Projekt übernehmen möchtest. Jedes Apply übernimmt nur die neuen Commits seit dem letzten. Wenn du mit dem Ergebnis zufrieden bist, pushe wie gewohnt und zerstöre die Sandbox. Siehe den [Nutzungsleitfaden](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md) für den vollständigen Arbeitsablauf.

## Demo

Erstellen einer Sandbox, Auffordern des Agenten und Anwenden der Ergebnisse:

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

## Funktionen

**Sandboxing**

- Sechs Backends: Docker, Podman, containerd (Kata), Apple Container, Tart und Seatbelt. Läuft auf Linux, macOS und Windows (WSL2).
- Wählbare Isolationsstärke pro Sandbox, von runc über gVisor bis zu Kata-VMs (QEMU oder Firecracker).
- Netzwerkrichtlinie pro Sandbox: offen, Whitelist oder keine.
- Minimale Umgebung in der Sandbox. Alles vom Host ist ein explizites Opt-in (`--env`, `--dir`).
- Ressourcenlimits (`--cpus`, `--memory`) und Portweiterleitung (`--port`).
- Günstige Workdir-Kopien: Ganzbaum-Klone auf macOS (APFS `clonefile`), Datei-Reflinks auf Linux-Dateisystemen, die sie unterstützen (btrfs, XFS). Dateisysteme ohne Reflink (ext4) erhalten eine normale Kopie.
- `.gitignore` wird berücksichtigt: Alles, was ignoriert wird, wird **NICHT** in die Sandbox kopiert (Sicherheitspraxis für Entwicklungsanmeldedaten auf der Festplatte).

**Anmeldedaten**

- Erkennt deine vorhandenen Agenten-Anmeldungen automatisch: API-Schlüssel, Abonnement-Anmeldedaten, macOS-Schlüsselbund.
- Credential-Brokering hält den API-Schlüssel host-seitig (Claude, Gemini und Codex heute); Aider- und OpenCode-Anmeldedaten werden als schreibgeschützte Datei-Mounts bereitgestellt.

**Arbeitsablauf**

- Kopieren/Diff/Anwenden mit git, das sandbox-seitig läuft, sodass Repos mit Filtern und Hooks korrekt funktionieren.
- Wende auf deine Weise an: Commits wiedergeben (Standard), zu einem einzelnen Patch squashen, `.patch`-Dateien exportieren, Commits per Ref auswählen oder zuerst `--dry-run`.
- Vollständiger Lebenszyklus: erstellen, anhängen, stoppen, neu starten, warten, klonen, zurücksetzen, zerstören. Der Agentenzustand überlebt Stopps und Neustarts.
- Headless-Einmalausführungen für Skripte und CI: `yoloai run --prompt ... --rm`, mit `--json`-Ausgabe bei jedem Befehl.
- Wenn der Agent beendet wird, fällt sein tmux-Bereich auf eine Shell zurück, damit du die Sandbox inspizieren kannst.

**Integration**

- Claude Code, Codex, Gemini CLI, Aider und OpenCode integriert, plus ein `shell`-Modus für alles andere.
- VS Code: Am Container anhängen oder einen Remote-Tunnel aus der Sandbox öffnen (`--vscode-tunnel`).
- MCP in beide Richtungen: `yoloai mcp serve` lässt einen äußeren Agenten Sandboxes als Werkzeuge steuern; `yoloai mcp proxy` führt MCP-Server in einer Sandbox aus.
- Profile: projektspezifische Images und Standardwerte (Dockerfile + Konfiguration, mit Vererbung).
- Erweiterungen: Füge eigene Unterbefehle als YAML-umhüllte Shell-Skripte hinzu (`yoloai x`).
- Einbettbar: Die CLI ist eine dünne Schicht über einer öffentlichen [Go-API](https://pkg.go.dev/github.com/kstenerud/yoloai).
- Einzelne statische Binärdatei. Der Zustand liegt in `~/.yoloai/` (verschiebbar mit `--data-dir`).

## Unterstützte Infrastruktur

### Sandbox-Backends

| Backend    | Unterstützte Hosts              | Abhängigkeiten                                                       |
|------------|------------------------------|--------------------------------------------------------------------|
| docker     | Linux, macOS, Windows (WSL2) | [Docker Engine](https://docs.docker.com/engine/install), [Docker Desktop](https://docs.docker.com/get-docker) oder [OrbStack](https://orbstack.dev) |
| podman     | Linux, macOS                 | [Podman](https://podman.io/get-started) (`brew install podman` auf 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 (beliebig)             | Keine (verwendet integriertes `sandbox-exec`)                                |

**Hinweis**: Tart bietet eine vollständige macOS-VM und ermöglicht dir, Simulatoren in der Sandbox auszuführen.

### Isolationsmodi

Optional das OCI-Runtime für stärkere Isolation aufrüsten. gVisor-Modi sind auf docker und podman verfügbar; die VM-Modi kommen mit dem containerd-Backend.

| Modus | Beschreibung |
|------|-------------|
| `container` | Standard `runc`: Standard-Linux-Namespaces und cgroups |
| `container-enhanced` | Userspace-Kernel (gVisor/runsc): Syscall-Interception, kein KVM erforderlich |
| `container-privileged` | Alle Capabilities, seccomp/AppArmor uneingeschränkt. Für Docker-in-Docker und Compose verwenden |
| `vm` | Kata Containers (QEMU): Hardware-VM-Isolation |
| `vm-enhanced` | Kata + Firecracker microVM: leichte VM-Isolation |

```bash
# gVisor für alle neuen Sandboxes verwenden
yoloai config set isolation container-enhanced

# Oder pro Sandbox
yoloai new task . --isolation container-enhanced
```

### Agenten

| Modus       | Beschreibung |
|------------|-------------|
| `claude`   | Führt [Claude Code](https://github.com/anthropics/claude-code) über API-Schlüssel oder Abonnement-Anmeldedaten aus (Standard) |
| `codex`    | Führt [Codex](https://github.com/openai/codex) über API-Schlüssel oder Abonnement-Anmeldedaten aus |
| `gemini`   | Führt [Gemini CLI](https://github.com/google-gemini/gemini-cli) über API-Schlüssel oder Abonnement-Anmeldedaten aus |
| `aider`    | Führt [Aider](https://github.com/Aider-AI/aider) aus (deine Konfiguration wird kopiert) |
| `opencode` | Führt [OpenCode](https://github.com/anomalyco/opencode) aus (deine Konfiguration wird kopiert) |
| `shell`    | Führt eine tmux-Shell mit allen Agenten-Anmeldedaten aus |
| `idle`     | Führt einen Leerlaufprozess aus, um MCP-Proxying zu ermöglichen |

Verwende `yoloai system agents`, um verfügbare Agenten aufzulisten.

## Mehr erfahren

- **[Nutzungsleitfaden](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md)**: Befehle, Flags, Workdir-Modi, Konfiguration, Sicherheit
- **[Roadmap](https://github.com/kstenerud/yoloai/blob/main/docs/ROADMAP.md)**: Geplante Funktionen
- **[Architektur](https://github.com/kstenerud/yoloai/blob/main/docs/contributors/architecture/README.md)**: Code-Navigation für Mitwirkende

## Status

Öffentliche Beta. Der Kernarbeitsablauf ist stabil und wird täglich genutzt; Schnittstellen können sich zwischen 0.x-Releases noch ändern, und jede bahnbrechende Änderung ist in [BREAKING-CHANGES](https://github.com/kstenerud/yoloai/blob/main/docs/BREAKING-CHANGES.md) dokumentiert. [Feedback ist willkommen.](https://github.com/kstenerud/yoloai/issues)

## Lizenz

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