Sandbox para revisão de código e verificação de PRs: prove que um patch funciona antes de aprovar

Um diff mostra o que um patch afirma fazer. Não mostra se o bug realmente sumiu, se o novo ramo de um if chega a ser executado ou se a atualização de uma dependência quebra o import numa instalação limpa. Os revisores sabem disso, e é por isso que tantas revisões terminam com "LGTM, desde que os testes passem".

Com patches escritos por IA, a lacuna aumenta. Um modelo produz código plausível rapidamente, e plausível é exatamente o tipo que passa despercebido por um revisor cansado. A solução barata é executar a mudança antes que alguém a aprove — num lugar onde ela não possa estragar nada.

A verificação: base, head, testes

A evidência mais convincente que um patch pode oferecer é uma reprodução que falha no código antigo e passa no novo. Uma sandbox transforma isso num script de 20 linhas. É uma microVM Firecracker com Python 3.12, Node.js 22, git e curl, iniciada em cerca de um segundo:

import os
from eqvps import Sandbox

REPO, BASE, HEAD = os.environ["REPO_URL"], os.environ["BASE_SHA"], os.environ["HEAD_SHA"]

def repro(sb, ref):
    sb.exec(f"cd /root/app && git checkout -q {ref}", timeout=55)
    return sb.exec("cd /root/app && python3 /root/repro.py", timeout=55).exit_code

with Sandbox.create(tariff="standard", ttl=1800) as sb:
    sb.exec(f"git clone -q {REPO} /root/app", timeout=55)
    sb.exec("cd /root/app && pip install -q -r requirements.txt", timeout=55)
    sb.upload("/root/repro.py", open("repro.py").read())
    before, after = repro(sb, BASE), repro(sb, HEAD)
    tests = sb.exec("cd /root/app && python3 -m pytest -q", background=True).wait()
    print(f"repro on base: {before}, on head: {after}; tests: {tests.state}, exit {tests.exit_code}")

repro.py é o trecho do relatório de bug. Se ele sai com código diferente de zero em base e com zero em head, o patch corrige o que diz corrigir. Publique essa linha, junto com o resumo dos testes, como comentário no pull request, e o revisor começa a partir de fatos.

A suíte de testes roda como tarefa em segundo plano, porque um único comando síncrono para aos 55 segundos. O TTL de 30 minutos limita quanto uma execução travada pode cobrar.

Agentes de revisão que executam código

A mesma ideia funciona para um revisor com IA. Conectado pelo servidor MCP, um agente tem ferramentas de sandbox: criar uma sandbox, executar um comando, enviar e baixar arquivos. Em vez de escrever "isso pode quebrar a compatibilidade com Python 3.8", ele faz checkout do branch, executa o código e cita o traceback — ou informa que está tudo certo.

Dê a esse agente um limite de gastos e um token somente leitura, e decida quais ferramentas ele pode chamar sem perguntar. As proteções do MCP listam cada ferramenta por nível de risco.

Qual plano

Sandboxes efêmeras são cobradas por segundo, com mínimo de 60 segundos. Se um revisor quiser voltar ao mesmo ambiente ao longo de alguns dias, crie-o como persistent: ele mantém o disco por até 30 dias e é cobrado por hora iniciada, então uma sandbox standard mantida para uma revisão de dois dias custa cerca de $3.17. Apague-a quando o pull request for mesclado.

Limites que vale conhecer

• Dois comandos por vez por conta. Mais que suficiente para revisões, que acontecem uma após a outra. Se você verificar dezenas de pull requests de uma vez, eles entram na fila.
• Sem portas de entrada. Não dá para abrir o app num navegador. Inicie-o lá dentro e teste com curl localhost a partir de um segundo comando.
• Sem Docker dentro. Testes que sobem contêineres ficam num runner em VPS.
• A internet de saída está aberta. É isso que faz o pip install funcionar. Não coloque na sandbox nada que você não entregaria ao autor do patch.

Para começar

Contas novas recebem $1 de tempo de sandbox, o que cobre mais de cem passadas de revisão no plano standard. A página de sandboxes traz os planos, a referência do SDK cada método usado acima, e SDK de Python em 5 minutos a configuração.

Relacionado: testes de CI isolados para o pipeline completo, e sandbox para agentes de IA para os agentes que escrevem o código em primeiro lugar.