LinuxParty

¿Eres de los que abres “un momentito” Warzone2100 o Brutal Chess y cuando te das cuenta han pasado dos horas? 😅
No estás solo. Las distracciones digitales son una epidemia moderna, y aunque existen aplicaciones que prometen ayudarte, los que usamos Linux sabemos que la mejor herramienta siempre es la que controlas tú mismo.

Hoy te muestro cómo crear tu propio sistema anti-distracciones en Linux: un script que detecta y mata automáticamente ciertos programas durante tu horario laboral, con un aviso en pantalla.
Así evitarás tentaciones… incluso cuando el demonio del ocio intente invocar Steam.

🚫 La idea

El concepto es simple:

• Definimos una lista de programas “prohibidos” (por ejemplo juegos o redes sociales).
• Establecemos una franja horaria y días en los que no queremos que se ejecuten.
• Si alguno se abre, el sistema lo detecta y lo cierra inmediatamente, mostrando un aviso con kdialog.

Esto se hace con un pequeño script en Bash llamado KillGuard.

⚙️ El script: killguard.sh

Guarda este código en /usr/local/bin/killguard.sh y dale permisos ejecutables:

sudo nano /usr/local/bin/killguard.sh
sudo chmod +x /usr/local/bin/killguard.sh

Y pega dentro lo siguiente:

#!/usr/bin/env bash
# ============================================================================
# KillGuard.sh – Bloquea programas de ocio en una franja horaria y días NO permitidos
# Muestra un aviso con kdialog/notify-send durante 5 s y mata el proceso.
# Autor: Javier Orovengua (2025)
# ============================================================================

# --- Lista de programas prohibidos ---
PROGRAMS=("warzone2100" "brutalchess")

# --- Configuración de calendario/horario ---
# Horas en formato 0..23 (bloqueo activo dentro de la franja)
BLOCK_START_HOUR=9     # p.ej. 09:00
BLOCK_END_HOUR=20      # p.ej. 20:00 (exclusivo). Si es 24, cubre hasta 23:59

# Días PERMITIDOS para usar los programas (abreviaturas en español: lun mar mié jue vie sáb dom)
# Por defecto, fines de semana permitidos.
ALLOW_DAYS=("sáb" "dom")

# Si quieres permitir también festivos, añádelos aquí en formato YYYY-MM-DD:
HOLIDAYS=("2025-12-25" "2025-01-01")
# Opcional: fichero con un festivo por línea (YYYY-MM-DD). Si existe, se suma.
HOLIDAYS_FILE="/etc/killguard_holidays.txt"

# Overrides para pruebas
# export FORCE_BLOCK=1  # fuerza bloqueo aunque hoy sea permitido / fuera de horario
# export FORCE_ALLOW=1  # fuerza permitir aunque toque bloquear
# export TODAY_IS_HOLIDAY=1  # marca hoy como festivo (permite)

# --- Comando de notificación ---
if command -v kdialog >/dev/null 2>&1 ; then
  notify_cmd() { kdialog --title "Aviso" --passivepopup "$1" 5; }
elif command -v notify-send >/dev/null 2>&1 ; then
  notify_cmd() { notify-send "Aviso" "$1" -t 5000; }
else
  notify_cmd() { echo "$(date +'%F %T') - $1"; }
fi

# --- Utilidades ---
in_array() {
  local needle="$1"; shift
  local x
  for x in "$@"; do [[ "$x" == "$needle" ]] && return 0; done
  return 1
}

# Traductor Mon..Sun -> lun..dom para no depender del locale del sistema
to_spanish_abbr() {
  case "$1" in
    Mon) echo "lun" ;;
    Tue) echo "mar" ;;
    Wed) echo "mié" ;;
    Thu) echo "jue" ;;
    Fri) echo "vie" ;;
    Sat) echo "sáb" ;;
    Sun) echo "dom" ;;
    *) echo "$1" ;;
  esac
}

is_within_block_hours() {
  local h="$1" start="$2" end="$3"

  # Forzar base 10 para evitar problemas con ceros a la izquierda (p.ej. "09")
  # shellcheck disable=SC2004
  h=$((10#$h))
  start=$((10#$start))
  end=$((10#$end))

  # Normal: start < end  → dentro si start <= h < end
  # Nocturna: start > end → dentro si h >= start OR h < end
  if (( start == end )); then
    # start==end → 24h (bloqueo todo el día)
    return 0
  elif (( start < end )); then
    (( h >= start && h < end )) && return 0 || return 1
  else
    (( h >= start || h < end )) && return 0 || return 1
  fi
}

is_holiday_today() {
  local today="$1"
  # 1) bandera rápida
  [[ "${TODAY_IS_HOLIDAY:-0}" == "1" ]] && return 0
  # 2) array embebido
  in_array "$today" "${HOLIDAYS[@]}" && return 0
  # 3) fichero de festivos
  if [[ -f "$HOLIDAYS_FILE" ]]; then
    # grep exacto por línea
    if grep -qx "$today" "$HOLIDAYS_FILE" 2>/dev/null; then
      return 0
    fi
  fi
  return 1
}

# --- Manejo de señal para salir limpiamente ---
trap 'echo "Saliendo de KillGuard..."; exit 0' INT TERM

# --- Bucle principal ---
while true; do
  day_en=$(LC_TIME=C date +%a)  # Mon..Sun (siempre en inglés, estable)
  dayname=$(to_spanish_abbr "$day_en")   # -> lun..dom
  today=$(date +%F)     # YYYY-MM-DD
  hour=$(date +%H)      # 00..23 (podría tener cero a la izquierda, ya gestionado)

  # ¿Hoy es día permitido?
  is_holiday_today "$today"
  is_holiday=$?   # 0 si festivo

  if in_array "$dayname" "${ALLOW_DAYS[@]}" || [[ $is_holiday -eq 0 ]]; then
    allow_today=1
  else
    allow_today=0
  fi

  # ¿Estamos dentro de la franja horaria de bloqueo?
  if is_within_block_hours "$hour" "$BLOCK_START_HOUR" "$BLOCK_END_HOUR"; then
    within_hours=1
  else
    within_hours=0
  fi

  # Lógica final de bloqueo
  do_block=0
  if [[ "${FORCE_ALLOW:-0}" == "1" ]]; then
    do_block=0
  elif [[ "${FORCE_BLOCK:-0}" == "1" ]]; then
    do_block=1
  else
    # Bloquea solo si HOY NO está permitido y además estamos dentro de la franja
    if [[ $allow_today -eq 0 && $within_hours -eq 1 ]]; then
      do_block=1
    fi
  fi

  if [[ $do_block -eq 1 ]]; then
    for prog in "${PROGRAMS[@]}"; do
      # Buscar procesos que coincidan (insensible a mayúsculas, por nombre o línea de comando)
      if pgrep -fia "$prog" >/dev/null 2>&1; then
        notify_cmd "Programa $prog no tiene permiso para ejecutarse ahora"
        # Intentar terminar con TERM
        pkill -TERM -f -i "$prog" >/dev/null 2>&1
        sleep 0.5
        # Si siguen vivos, matar con KILL
        if pgrep -fia "$prog" >/dev/null 2>&1; then
          pkill -KILL -f -i "$prog" >/dev/null 2>&1
        fi
      fi
    done
  fi

  # Espera 5 s antes de comprobar de nuevo
  sleep 5
done

🧩 Servicio systemd de usuario

Para que KillGuard se inicie automáticamente cada vez que inicias sesión, crea este servicio:

mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/killguard.service <<'EOF'
[Unit]
Description=KillGuard: bloquea apps no permitidas en horario laboral
After=graphical-session.target
Wants=graphical-session.target

[Service]
Type=simple
ExecStart=/usr/local/bin/killguard.sh
Restart=always
RestartSec=3
NoNewPrivileges=yes

[Install]
WantedBy=default.target
EOF

Y actívalo con:

systemctl --user daemon-reload
systemctl --user enable --now killguard.service

💬 Qué hace exactamente

Cada cinco segundos, el script:

1. Comprueba el día y la hora.
2. Si no estás en un día permitido (ni festivo) y estás dentro del horario bloqueado,
   busca los procesos listados en PROGRAMS.
3. Si alguno está corriendo, lo mata sin piedad (TERM → KILL)
   y muestra un mensaje en pantalla:

   “Programa warzone2100 no tiene permiso para ejecutarse ahora”

🧠 Ventajas de hacerlo tú mismo

• No dependes de software de terceros ni de sistemas de control paternalista.
• Puedes personalizar completamente el comportamiento (horarios, programas, días libres).
• Funciona en cualquier entorno KDE, GNOME, XFCE o incluso sin interfaz gráfica.
• Y lo más importante: te ayuda a mantener el foco sin tentaciones.

🧪 Modo de prueba

Para probar el script en cualquier momento, ejecuta:

export FORCE_BLOCK=1
systemctl --user restart killguard.service

y abre uno de los programas bloqueados: verás cómo se cierra solo con un aviso.

✅ Conclusión

El verdadero poder de Linux está en su libertad y control.
Este pequeño script es un recordatorio de que no necesitas grandes herramientas de productividad para mantenerte enfocado:
solo unas líneas de Bash, un poco de disciplina…
y una ventana de kdialog que te diga:

“No, ahora no es momento de jugar.”

¿Te distraes fácilmente?
Entonces KillGuard puede convertirse en tu mejor asistente personal.
Y lo mejor: ¡tú lo programaste! 😎