yoloai

# yoloAI

**Executor em sandbox para agentes de codificação com IA. Sem fadiga de permissões, sem credenciais no ambiente, sem alterações no seu projeto até você aprová-las.**

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

Agentes de codificação com IA funcionam melhor com as proteções desativadas, e essa é uma péssima forma de executá-los na sua máquina real. O yoloAI oferece ao agente um sandbox descartável onde ele pode editar qualquer coisa e executar qualquer coisa, sem supervisão. Seu projeto, suas credenciais e sua rede permanecem sob seu controle. Quando o agente terminar, revise o diff e aplique o que deseja manter.

```text
Você                          Sandbox                        Seu projeto
 │                              │                                │
 ├─ yoloai new fix-bug .        ├─ cópia do projeto no sandbox   │
 │                              │                                │
 ├─ << seus prompts >>          ├─ agente trabalha livremente    │
 │                              │  (sem prompts de permissão)    │
 │                              │                                │
 ├─ yoloai diff fix-bug         ├─ mostra o que mudou            │
 │                              │                                │
 ├─ yoloai apply fix-bug        │                                ├─ patches aplicados
 │  (você escolhe quais)        │                                │
 │                              │                                │
 ├─ yoloai destroy fix-bug      ├─ destrói o sandbox             │
```

## Por quê?

Os prompts de permissão existem porque os agentes cometem erros. Após a centésima aprovação/negação, você para de lê-los, e `--dangerously-skip-permissions` está a um agente confuso de distância de um dia muito ruim. O yoloAI reduz o raio de impacto até que os prompts se tornem desnecessários:

- **Seus arquivos estão seguros.** O agente trabalha em uma cópia isolada do seu projeto. O `diff` mostra exatamente o que mudou, o `apply` aplica patches no seu projeto real preservando commits individuais, e seus originais nunca mudam até você aplicar.
- **Seus segredos estão seguros.** O sandbox inicia a partir de um ambiente mínimo, construído localmente; as variáveis de ambiente do host permanecem no host. As credenciais chegam como montagens de arquivos somente leitura, nunca como variáveis de ambiente. Quando o broker de credenciais se aplica (Claude, Gemini e Codex hoje, ativado por padrão), a chave de API permanece inteiramente no lado do host: um proxy local a injeta no caminho até o provedor, então mesmo um agente totalmente comprometido não tem nada para exfiltrar.
- **Sua rede é sua.** `--network-isolated` restringe a saída aos endpoints da API do agente mais os domínios que você permitir. `--network-none` remove a rede completamente.
- **Sua máquina está isolada.** Escolha seu nível de conforto, desde namespaces do Linux até gVisor e VMs de hardware.

Consulte [Segurança](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md#security) para o modelo completo, incluindo limitações honestas.

## Instalação

### Binário pré-compilado (recomendado)

Baixe o arquivo para sua plataforma na [última versão](https://github.com/kstenerud/yoloai/releases/latest), extraia o binário `yoloai` e coloque-o no seu `PATH`:

```bash
# Linux x86-64 (substitua por linux_arm64 / darwin_amd64 / darwin_arm64 conforme necessário).
# Defina VERSION como a tag mostrada na página da última versão vinculada acima, sem
# o "v" inicial — ex.: VERSION=1.2.3 para a 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/
```

Cada arquivo também inclui completions de shell, o `LICENSE` e o changelog. As versões são assinadas com cosign (`checksums.txt`) e possuem proveniência de build do GitHub (`gh attestation verify yoloai_… --repo kstenerud/yoloai`). Pacotes Debian/RPM também são anexados a cada versão.

### Homebrew (macOS / Linux)

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

### Usando `go install`

```bash
# Última versão
go install github.com/kstenerud/yoloai/cmd/yoloai@latest

# Última versão de desenvolvimento (instável)
go install github.com/kstenerud/yoloai/cmd/yoloai@main
```

Requer Go 1.26+. O binário é colocado em `$GOPATH/bin` (normalmente `~/go/bin`).

### A partir do código-fonte

```bash
git clone https://github.com/kstenerud/yoloai.git
cd yoloai
git checkout "$(git describe --tags --abbrev=0)"   # tag da versão mais recente; ou permaneça na main para a versão de desenvolvimento
make build
sudo install yoloai /usr/local/bin/
```

É um único binário Go sem dependências de runtime além do backend escolhido. Na primeira execução, o yoloAI constrói sua imagem base e cria `~/.yoloai/` (ou o diretório que você apontar com `--data-dir`).

## Início rápido

### Não interativo

```bash
# Autentique-se (o yoloAI capta credenciais existentes automaticamente)
export ANTHROPIC_API_KEY=sk-ant-...   # Claude Code
export GEMINI_API_KEY=...             # Gemini CLI
# Ou apenas deixe-o captar sua sessão já autenticada

# 1. Crie um sandbox. O agente começa a trabalhar imediatamente quando você fornece um prompt
yoloai new fix-bug ./my-project --prompt "corrija os testes que estão falhando"

# 2. Veja o que o agente mudou
yoloai diff fix-bug

# 3. Aplique as partes boas ao seu projeto real
yoloai apply fix-bug

# 4. Descarte o sandbox
yoloai destroy fix-bug
```

### Interativo

```bash
yoloai new exploration ./my-project -a
# Você está dentro do agente, executando em tmux no sandbox.
#   Ctrl-B, D para desconectar.
#   yoloai attach exploration para reconectar.
```

### Iterando

Para sessões mais longas, trabalhe em um loop: diga ao agente para fazer commits conforme avança e execute `yoloai apply` de outro terminal sempre que quiser trazer os commits concluídos para o seu projeto real. Cada apply traz apenas os novos commits desde o último. Quando estiver satisfeito com o resultado, faça push como de costume e destrua o sandbox. Consulte o [Guia de Uso](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md) para o fluxo de trabalho completo.

## Demonstração

Criando um sandbox, enviando um prompt ao agente e aplicando os resultados:

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

## Recursos

**Sandboxing**

- Seis backends: Docker, Podman, containerd (Kata), Apple Container, Tart e Seatbelt. Funciona em Linux, macOS e Windows (WSL2).
- Força de isolamento selecionável por sandbox, de runc a gVisor até VMs Kata (QEMU ou Firecracker).
- Política de rede por sandbox: aberta, lista de permissões ou nenhuma.
- Ambiente mínimo dentro do sandbox. Qualquer coisa do host é um opt-in explícito (`--env`, `--dir`).
- Limites de recursos (`--cpus`, `--memory`) e encaminhamento de portas (`--port`).
- Cópias baratas do diretório de trabalho: clones de árvore inteira no macOS (APFS `clonefile`), reflinks por arquivo em sistemas de arquivos Linux que os suportam (btrfs, XFS). Sistemas de arquivos sem reflink (ext4) recebem uma cópia normal.
- `.gitignore` respeitado: qualquer coisa ignorada **NÃO** é copiada para o sandbox (prática de segurança para credenciais de desenvolvimento em disco).

**Credenciais**

- Capta automaticamente seus logins de agente existentes: chaves de API, credenciais de assinatura, Keychain do macOS.
- O broker de credenciais mantém a chave de API no lado do host (Claude, Gemini e Codex hoje); as credenciais do Aider e do OpenCode são entregues como montagens de arquivos somente leitura.

**Fluxo de trabalho**

- Copy/diff/apply com git executando no lado do sandbox, para que repositórios com filtros e hooks se comportem corretamente.
- Aplique do seu jeito: reproduza commits (padrão), squash em um único patch, exporte arquivos `.patch`, selecione commits por ref ou use `--dry-run` primeiro.
- Ciclo de vida completo: create, attach, stop, restart, wait, clone, reset, destroy. O estado do agente sobrevive a paradas e reinícios.
- Execuções únicas headless para scripts e CI: `yoloai run --prompt ... --rm`, com saída `--json` em todos os comandos.
- Quando o agente sai, seu painel tmux cai para um shell para que você possa inspecionar o sandbox.

**Integração**

- Claude Code, Codex, Gemini CLI, Aider e OpenCode integrados, além de um modo `shell` para qualquer outra coisa.
- VS Code: anexe-se ao contêiner ou abra um Remote Tunnel de dentro do sandbox (`--vscode-tunnel`).
- MCP em ambas as direções: `yoloai mcp serve` permite que um agente externo controle sandboxes como ferramentas; `yoloai mcp proxy` executa servidores MCP dentro de um sandbox.
- Perfis: imagens e padrões por projeto (Dockerfile + config, com herança).
- Extensões: adicione seus próprios subcomandos como scripts shell encapsulados em YAML (`yoloai x`).
- Embutível: a CLI é uma camada fina sobre uma [API Go](https://pkg.go.dev/github.com/kstenerud/yoloai) pública.
- Binário estático único. O estado vive em `~/.yoloai/` (realocável com `--data-dir`).

## Infraestrutura suportada

### Backends de sandbox

| Backend    | Hosts suportados              | Dependências                                                       |
|------------|------------------------------|--------------------------------------------------------------------|
| 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` no 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 (qualquer)             | Nenhuma (usa o `sandbox-exec` integrado)                                |

**Nota**: O Tart fornece uma VM macOS completa, permitindo executar simuladores dentro do sandbox.

### Modos de isolamento

Opcionalmente, atualize o runtime OCI para um isolamento mais forte. Os modos gVisor estão disponíveis no docker e no podman; os modos de VM vêm com o backend containerd.

| Modo | Descrição |
|------|-------------|
| `container` | `runc` padrão: namespaces e cgroups padrão do Linux |
| `container-enhanced` | Kernel em userspace (gVisor/runsc): interceptação de syscalls, sem necessidade de KVM |
| `container-privileged` | Todas as capabilities, seccomp/AppArmor sem confinamento. Use para Docker-in-Docker e Compose |
| `vm` | Kata Containers (QEMU): isolamento por VM de hardware |
| `vm-enhanced` | Kata + Firecracker microVM: isolamento por VM leve |

```bash
# Use gVisor para todos os novos sandboxes
yoloai config set isolation container-enhanced

# Ou por sandbox
yoloai new task . --isolation container-enhanced
```

### Agentes

| Modo       | Descrição |
|------------|-------------|
| `claude`   | Executa o [Claude Code](https://github.com/anthropics/claude-code) via chave de API ou credenciais de assinatura (padrão) |
| `codex`    | Executa o [Codex](https://github.com/openai/codex) via chave de API ou credenciais de assinatura |
| `gemini`   | Executa o [Gemini CLI](https://github.com/google-gemini/gemini-cli) via chave de API ou credenciais de assinatura |
| `aider`    | Executa o [Aider](https://github.com/Aider-AI/aider) (sua configuração é copiada) |
| `opencode` | Executa o [OpenCode](https://github.com/anomalyco/opencode) (sua configuração é copiada) |
| `shell`    | Executa um shell tmux com todas as credenciais do agente semeadas |
| `idle`     | Executa um processo ocioso para permitir proxy MCP |

Use `yoloai system agents` para listar os agentes disponíveis.

## Saiba mais

- **[Guia de Uso](https://github.com/kstenerud/yoloai/blob/main/docs/GUIDE.md)**: comandos, flags, modos de diretório de trabalho, configuração, segurança
- **[Roadmap](https://github.com/kstenerud/yoloai/blob/main/docs/ROADMAP.md)**: próximos recursos
- **[Arquitetura](https://github.com/kstenerud/yoloai/blob/main/docs/contributors/architecture/README.md)**: navegação no código para contribuidores

## Status

Beta público. O fluxo de trabalho principal é estável e exercitado diariamente; as interfaces podem mudar entre versões 0.x, e toda mudança que quebra compatibilidade é documentada em [BREAKING-CHANGES](https://github.com/kstenerud/yoloai/blob/main/docs/BREAKING-CHANGES.md). [Feedback é bem-vindo.](https://github.com/kstenerud/yoloai/issues)

## Licença

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