Dê autonomia real ao Claude Code sem comprometer seu sistema

Autor: Harry Philippe Mbouyap. Todo o código abaixo é MIT e está em um pequeno repositório que você pode
clonar e executar: https://github.com/hbouyap/claude-code-safe-automation

Fazer um agente de IA escrever código é um problema resolvido. A parte que mantém as equipes acordadas à noite
es diferente: você confia que ele execute comandos na sua máquina, sem supervisão?

Um rm -rf no diretório errado, um git push --force para o branch errado, e "o agente
me salvou uma tarde" se torna "o agente me custou uma semana." Portanto, a maioria das pessoas mantém o agente em uma
coleira curta — aprovando cada passo — o que desperdiça a maior parte do valor.

Há um meio termo melhor. Você pode dar a um agente uma verdadeira autonomia em um fluxo de trabalho e ainda assim fazê-lo
estruturalmente incapaz de fazer as poucas coisas que poderiam causar danos. Aqui está a abordagem em três camadas que eu
uso com Claude Code.

Camada 1 — Permissões escopadas

Comece dizendo ao agente o que ele pode tocar, em .claude/settings.json:

{
  "permissions": {
    "allow": ["Bash(ls:*)", "Bash(git status:*)", "Bash(git diff:*)", "Read(*)", "Grep(*)"],
    "deny": ["Bash(sudo:*)", "Read(.env)", "Read(**/secrets/**)"]
  }
}

Isso é necessário, mas não suficiente. Os globs de permissão são grosseiros — Bash(git:*) permite tanto
git status quanto git push --force. Para os comandos que realmente importam, você quer lógica, não
un glob. Essa é a próxima camada.

Camada 2 — Um gancho de guarda PreToolUse

Claude Code pode executar um gancho antes de cada chamada de ferramenta. Se o gancho sair com o código 2, a chamada
é negada e a razão é devolvida ao modelo. Esse é o lugar perfeito para colocar uma
lista de negação de coisas que nunca devem ser executadas sem supervisão:

import json, re, sys

DANGEROUS = [
    # rm -rf em qualquer ordem de flag, além do alias do PowerShell rm -Recurse -Force
    (r"\brm\b(?=.*(?:-[a-z]*r|--recursive))(?=.*(?:-[a-z]*f|--force))", "exclusão forçada recursiva"),
    (r"\bremove-item\b(?=.*-rec)(?=.*-for)", "exclusão forçada recursiva (Windows)"),
    (r"\bgit\s+push\b(?=.*(?:--force\b|\s-f\b))", "push forçado pode sobrescrever o histórico"),
    (r"\bgit\s+reset\s+--hard\b", "reset forçado descarta o trabalho"),
    (r"\b(?:curl|wget)\b.*\|\s*(?:sudo\s+)?(?:sh|bash)\b", "encaminhar para shell da rede"),
    # ... bombas de fork, gravações de disco brutas, sudo, formatar, shred, del /s, rmdir /s
]

def main():
    event = json.load(sys.stdin)
    if event.get("tool_name") != "Bash":
        return 0
    command = event.get("tool_input", {}).get("command", "")
    for pattern, reason in DANGEROUS:
        if re.search(pattern, command, re.IGNORECASE):
            print(f"guarda: bloqueado -- {reason}", file=sys.stderr)
            return 2   # Claude Code trata a saída 2 como "negar"
    return 0

sys.exit(main())

Dois detalhes que importam mais do que parecem:

1. Cobrir o Windows também.