🌱 Empieza aquí · Guardia de comandos peligrosos

Para ti (el humano)

Abre esta carpeta con Claude Code o Cowork y dile a tu asistente:

"Siembra esta semilla 🌱"

Y ya. Tu asistente hace todo lo técnico. Tú solo confirmas cuando te pregunte lo delicado. Si ves algunas palabras en inglés en la pantalla, ni caso: él te guía.

¿Otras formas de decírselo? "instala este hook", "pon a funcionar la guardia de comandos", "activa el guardián que frena comandos peligrosos". Te entiende igual.

Esta semilla instala un hook (gancho de automatización): un guardián que revisa cada comando de terminal justo antes de que tu asistente lo ejecute y frena en seco las operaciones que podrían borrar tu trabajo o tu sistema (como un rm -rf en la carpeta equivocada o un git push --force que pisa el trabajo de tu equipo).

Para el asistente que siembra 🤖

Eres el asistente. Instala este hook siguiendo estos pasos. No le pidas al humano nada técnico; tú resuelves y solo confirmas lo delicado. Este componente tiene dos archivos: el motor (guard-bash.py, donde vive la inteligencia) y el envoltorio (guard-bash.sh, que es el que se registra como hook y llama al motor). Ambos van juntos en la misma carpeta.

1. Copia los dos archivos del kernel

Copia kernel/guard-bash.py y kernel/guard-bash.sh a la carpeta de hooks de la plataforma del usuario:

• Claude Code / Cowork: cópialos a ~/.claude/hooks/ (esta es la ruta que el envoltorio espera por defecto).
  • En macOS/Linux ~/.claude/hooks/ ya existe o se crea con mkdir -p ~/.claude/hooks.
  • En Windows la ruta equivalente es %USERPROFILE%\.claude\hooks\.

mkdir -p ~/.claude/hooks
cp kernel/guard-bash.py ~/.claude/hooks/guard-bash.py
cp kernel/guard-bash.sh ~/.claude/hooks/guard-bash.sh

Mantén los dos archivos juntos, en la misma carpeta. El envoltorio busca el motor al lado suyo, así que funciona sin importar en qué carpeta los coloques.

2. Dale permiso de ejecución (macOS / Linux)

chmod +x ~/.claude/hooks/guard-bash.sh ~/.claude/hooks/guard-bash.py

En Windows este paso no aplica (se invoca con bash, que viene con Git para Windows).

3. Conéctalo como hook PreToolUse en settings.json

Abre el settings.json del usuario (~/.claude/settings.json) y agrega este bloque dentro de hooks. Si ya existe una sección PreToolUse, añade el objeto al arreglo existente, no lo dupliques.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash ~/.claude/hooks/guard-bash.sh"
          }
        ]
      }
    ]
  }
}

matcher: "Bash" hace que el guardián revise cada comando de terminal antes de ejecutarlo. Los comandos inofensivos pasan al instante; solo se frenan los patrones peligrosos.

4. Verificación post-siembra (obligatoria)

Comprueba que el guardián de verdad frena algo peligroso y de verdad deja pasar lo inofensivo. Copia y corre esto tal cual:

a) Frena un comando delicado (debe salir código 2):

echo '{"tool_input":{"command":"git push --force origin main"}}' | bash ~/.claude/hooks/guard-bash.sh; echo "codigo=$?"

Salida esperada: un mensaje que empieza con PAUSA DELIBERATIVA: y codigo=2.

b) Deja pasar un comando inofensivo (debe salir código 0) — y NO se confunde por una palabra dentro de un texto:

echo '{"tool_input":{"command":"git commit -m \"remove sudo from setup\""}}' | bash ~/.claude/hooks/guard-bash.sh; echo "codigo=$?"

Salida esperada: sin mensajes y codigo=0. Aunque el mensaje de commit contiene la palabra sudo, el guardián NO lo frena porque no es el comando real. Ese es justo el truco de esta semilla.

Si viste codigo=2 en la prueba (a) y codigo=0 en la (b), el guardián funciona.

Notas de configuración

• Requiere Python 3 para la inteligencia completa. Si no hay Python, el envoltorio cae a una red de seguridad mínima que solo cubre lo catastrófico (rm -rf /, mkfs, fork bomb).
• GUARD_BASH_ALLOW_SUDO (opcional) = variable de entorno. Si la defines con cualquier valor, el guardián deja pasar sudo sin pausar. Útil en servidores, CI o bots donde sudo es rutina. El resto de las guardias sigue activo.
• El guardián no depende de rutas fijas del proyecto: opera sobre el comando que se está por ejecutar, venga de donde venga.

✅ ¿Cómo sé que funcionó?

A partir de ahora, cada vez que tu asistente vaya a correr un comando de terminal, este guardián lo revisa primero. Si el comando es inofensivo, ni te enteras: corre normal. Si es catastrófico (borraría todo tu sistema o tus archivos), lo bloquea y punto. Y si es delicado pero a veces legítimo (borrar una carpeta, un push --force, un DROP TABLE), lo pausa y obliga a tu asistente a justificarlo o a pedirte permiso antes de seguir. Tú te quedas con la última palabra en lo que importa, sin tener que revisar cada comando a mano.