357 lines
14 KiB
Bash
Executable File
357 lines
14 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# reboot_all_claudes — Cierra todas las terminales con una sesion de Claude Code
|
|
# corriendo y las relanza retomando exactamente la sesion que tenian
|
|
# (claude --resume <sessionId>). Por defecto es DRY-RUN: imprime el plan sin
|
|
# tocar nada. Usar --go para ejecutarlo de verdad.
|
|
#
|
|
# Mecanismo (Claude Code 2.1.x sobre Linux + kitty):
|
|
# - pgrep -x claude -> PIDs de las sesiones interactivas vivas.
|
|
# - ~/.claude/sessions/<PID>.json -> mapea PID a {sessionId, cwd, status, procStart}.
|
|
# - Anti-PID-reciclado: procStart del JSON debe coincidir con el campo 22 de
|
|
# /proc/<PID>/stat; ademas kill -0 <PID> debe tener exito.
|
|
# - KITTY_PID del environ del proceso -> ventana kitty a cerrar.
|
|
# - cmdline del proceso -> flags originales a conservar (sin argv0 ni resume previos).
|
|
# - Relanzamiento detached (setsid) para sobrevivir al cierre de la propia terminal.
|
|
set -euo pipefail
|
|
IFS=$' \t\n'
|
|
|
|
reboot_all_claudes() {
|
|
local mode="dry" # dry | go
|
|
local resume_mode="resume" # resume | continue | none
|
|
local exclude_current=0
|
|
local only_idle=0
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Parseo de argumentos
|
|
# -----------------------------------------------------------------------
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--go|--yes)
|
|
mode="go"
|
|
;;
|
|
--resume-mode)
|
|
shift
|
|
resume_mode="${1:-}"
|
|
case "$resume_mode" in
|
|
resume|continue|none) ;;
|
|
*)
|
|
echo "reboot_all_claudes: --resume-mode invalido: '$resume_mode' (usa resume|continue|none)" >&2
|
|
return 2
|
|
;;
|
|
esac
|
|
;;
|
|
--exclude-current)
|
|
exclude_current=1
|
|
;;
|
|
--only-idle)
|
|
only_idle=1
|
|
;;
|
|
-h|--help)
|
|
cat <<'USAGE'
|
|
Uso: reboot_all_claudes [opciones]
|
|
|
|
Cierra todas las terminales con una sesion de Claude Code corriendo y las
|
|
relanza retomando la misma sesion (claude --resume <sessionId>).
|
|
|
|
Por defecto es DRY-RUN (accion destructiva => default seguro): imprime el plan
|
|
y NO mata ni relanza nada.
|
|
|
|
Opciones:
|
|
--go, --yes Ejecuta de verdad (kills + relanzamientos detached).
|
|
--resume-mode <modo> resume (default) | continue | none.
|
|
resume -> claude --resume <sessionId>
|
|
continue -> claude --continue
|
|
none -> claude (sesion nueva en el mismo cwd)
|
|
--exclude-current No cierra ni relanza la terminal desde la que se invoca.
|
|
--only-idle Omite sesiones con status busy (no pierde turnos en vuelo).
|
|
-h, --help Muestra esta ayuda.
|
|
|
|
Ejemplos:
|
|
reboot_all_claudes # dry-run, ve el plan
|
|
reboot_all_claudes --go --exclude-current # reinicia todas menos esta terminal
|
|
USAGE
|
|
return 0
|
|
;;
|
|
*)
|
|
echo "reboot_all_claudes: opcion desconocida: '$1' (usa -h)" >&2
|
|
return 2
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Detectar el PID de la sesion actual subiendo por la cadena de ancestros
|
|
# hasta encontrar un proceso cuyo comm sea exactamente "claude".
|
|
# -----------------------------------------------------------------------
|
|
local current_claude_pid=""
|
|
if [[ "$exclude_current" -eq 1 ]]; then
|
|
local walk="$$"
|
|
local guard=0
|
|
while [[ -n "$walk" && "$walk" != "0" && "$walk" != "1" ]]; do
|
|
local comm=""
|
|
comm="$(cat "/proc/$walk/comm" 2>/dev/null || true)"
|
|
if [[ "$comm" == "claude" ]]; then
|
|
current_claude_pid="$walk"
|
|
break
|
|
fi
|
|
# campo 4 de /proc/<pid>/stat es el PPID
|
|
walk="$(awk '{print $4}' "/proc/$walk/stat" 2>/dev/null || true)"
|
|
guard=$((guard + 1))
|
|
[[ "$guard" -gt 64 ]] && break
|
|
done
|
|
fi
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Recolectar las sesiones vivas y validarlas.
|
|
# -----------------------------------------------------------------------
|
|
local sessions_dir="$HOME/.claude/sessions"
|
|
local pids=""
|
|
pids="$(pgrep -x claude 2>/dev/null || true)"
|
|
|
|
if [[ -z "$pids" ]]; then
|
|
echo "reboot_all_claudes: no hay sesiones de Claude Code vivas (pgrep -x claude vacio)."
|
|
return 0
|
|
fi
|
|
|
|
# Arrays paralelos con el plan validado.
|
|
local -a plan_pid plan_kitty plan_status plan_cwd plan_sid plan_cmd plan_skip plan_skipreason
|
|
|
|
local pid
|
|
for pid in $pids; do
|
|
# Validacion 1: el proceso debe seguir vivo.
|
|
if ! kill -0 "$pid" 2>/dev/null; then
|
|
continue
|
|
fi
|
|
|
|
# Validacion 2: debe existir su JSON de sesion.
|
|
local json="$sessions_dir/$pid.json"
|
|
if [[ ! -f "$json" ]]; then
|
|
continue
|
|
fi
|
|
|
|
# Parsear el JSON con python3 (campos sessionId, cwd, status, procStart).
|
|
# Salida: lineas "clave=valor" en orden fijo.
|
|
local parsed=""
|
|
parsed="$(python3 - "$json" <<'PY' 2>/dev/null || true
|
|
import json, sys
|
|
try:
|
|
with open(sys.argv[1]) as fh:
|
|
d = json.load(fh)
|
|
except Exception:
|
|
sys.exit(0)
|
|
print("sessionId=" + str(d.get("sessionId", "")))
|
|
print("cwd=" + str(d.get("cwd", "")))
|
|
print("status=" + str(d.get("status", "")))
|
|
print("procStart=" + str(d.get("procStart", "")))
|
|
PY
|
|
)"
|
|
[[ -z "$parsed" ]] && continue
|
|
|
|
local sid cwd status proc_start_json
|
|
sid="$(printf '%s\n' "$parsed" | sed -n 's/^sessionId=//p')"
|
|
cwd="$(printf '%s\n' "$parsed" | sed -n 's/^cwd=//p')"
|
|
status="$(printf '%s\n' "$parsed" | sed -n 's/^status=//p')"
|
|
proc_start_json="$(printf '%s\n' "$parsed" | sed -n 's/^procStart=//p')"
|
|
|
|
[[ -z "$sid" ]] && continue
|
|
|
|
# Validacion 3 (anti-PID-reciclado): procStart del JSON debe coincidir
|
|
# con el campo 22 de /proc/<PID>/stat.
|
|
local proc_start_real=""
|
|
proc_start_real="$(awk '{print $22}' "/proc/$pid/stat" 2>/dev/null || true)"
|
|
if [[ -n "$proc_start_json" && "$proc_start_json" != "$proc_start_real" ]]; then
|
|
# JSON huerfano de un PID reciclado: omitir.
|
|
continue
|
|
fi
|
|
|
|
# KITTY_PID de la ventana kitty (vacio si claude no corre en kitty).
|
|
local kitty_pid=""
|
|
kitty_pid="$(tr '\0' '\n' < "/proc/$pid/environ" 2>/dev/null | sed -n 's/^KITTY_PID=//p' | head -n1)"
|
|
|
|
# Flags originales: leer cmdline, descartar argv0 (claude) y cualquier
|
|
# flag de resume/continue previo para no duplicarlos.
|
|
local raw_cmd=""
|
|
raw_cmd="$(tr '\0' '\n' < "/proc/$pid/cmdline" 2>/dev/null || true)"
|
|
local -a kept_flags=()
|
|
local first=1 tok skipnext=0
|
|
while IFS= read -r tok; do
|
|
[[ -z "$tok" ]] && continue
|
|
if [[ "$first" -eq 1 ]]; then
|
|
# argv0 (la ruta o nombre de claude) — descartar.
|
|
first=0
|
|
continue
|
|
fi
|
|
if [[ "$skipnext" -eq 1 ]]; then
|
|
skipnext=0
|
|
continue
|
|
fi
|
|
case "$tok" in
|
|
--resume|--continue|-r|-c)
|
|
# Resume/continue previos: omitir (y su posible valor para --resume).
|
|
if [[ "$tok" == "--resume" || "$tok" == "-r" ]]; then
|
|
skipnext=1
|
|
fi
|
|
continue
|
|
;;
|
|
esac
|
|
kept_flags+=("$tok")
|
|
done <<< "$raw_cmd"
|
|
|
|
# Construir la estrategia de resume.
|
|
local -a launch_args=()
|
|
case "$resume_mode" in
|
|
resume) launch_args=("--resume" "$sid") ;;
|
|
continue) launch_args=("--continue") ;;
|
|
none) launch_args=() ;;
|
|
esac
|
|
launch_args+=("${kept_flags[@]}")
|
|
|
|
# Comando claude final (para mostrar y ejecutar).
|
|
local claude_cmd="claude"
|
|
local a
|
|
for a in "${launch_args[@]}"; do
|
|
claude_cmd+=" $(printf '%q' "$a")"
|
|
done
|
|
|
|
# Decidir si se omite esta sesion del plan.
|
|
local skip=0 skipreason=""
|
|
if [[ "$exclude_current" -eq 1 && -n "$current_claude_pid" && "$pid" == "$current_claude_pid" ]]; then
|
|
skip=1
|
|
skipreason="terminal actual (--exclude-current)"
|
|
elif [[ "$only_idle" -eq 1 && "$status" == "busy" ]]; then
|
|
skip=1
|
|
skipreason="busy (--only-idle)"
|
|
fi
|
|
|
|
plan_pid+=("$pid")
|
|
plan_kitty+=("${kitty_pid:-}")
|
|
plan_status+=("${status:-?}")
|
|
plan_cwd+=("${cwd:-?}")
|
|
plan_sid+=("$sid")
|
|
plan_cmd+=("$claude_cmd")
|
|
plan_skip+=("$skip")
|
|
plan_skipreason+=("$skipreason")
|
|
done
|
|
|
|
local total="${#plan_pid[@]}"
|
|
if [[ "$total" -eq 0 ]]; then
|
|
echo "reboot_all_claudes: ninguna sesion valida encontrada (todos los PIDs eran huerfanos o reciclados)."
|
|
return 0
|
|
fi
|
|
|
|
# -----------------------------------------------------------------------
|
|
# Imprimir el plan (siempre, tanto en dry-run como en --go).
|
|
# -----------------------------------------------------------------------
|
|
echo "reboot_all_claudes — modo: ${mode} resume: ${resume_mode} sesiones: ${total}"
|
|
echo
|
|
printf '%-8s %-9s %-7s %-6s %-38s %s\n' "PID" "KITTY" "STATUS" "ACCION" "SESSION_ID" "CWD"
|
|
printf '%-8s %-9s %-7s %-6s %-38s %s\n' "--------" "---------" "-------" "------" "--------------------------------------" "---"
|
|
|
|
local i busy_count=0 act_count=0
|
|
for ((i = 0; i < total; i++)); do
|
|
local accion="reinic"
|
|
if [[ "${plan_skip[$i]}" -eq 1 ]]; then
|
|
accion="OMITE"
|
|
else
|
|
act_count=$((act_count + 1))
|
|
fi
|
|
[[ "${plan_status[$i]}" == "busy" ]] && busy_count=$((busy_count + 1))
|
|
printf '%-8s %-9s %-7s %-6s %-38s %s\n' \
|
|
"${plan_pid[$i]}" \
|
|
"${plan_kitty[$i]:-(none)}" \
|
|
"${plan_status[$i]}" \
|
|
"$accion" \
|
|
"${plan_sid[$i]}" \
|
|
"${plan_cwd[$i]}"
|
|
if [[ "${plan_skip[$i]}" -eq 1 ]]; then
|
|
echo " -> omitida: ${plan_skipreason[$i]}"
|
|
else
|
|
echo " -> ${plan_cmd[$i]}"
|
|
fi
|
|
done
|
|
echo
|
|
|
|
# Aviso explicito de sesiones busy que SI se van a reiniciar.
|
|
if [[ "$only_idle" -eq 0 ]]; then
|
|
local warned=0
|
|
for ((i = 0; i < total; i++)); do
|
|
if [[ "${plan_skip[$i]}" -eq 0 && "${plan_status[$i]}" == "busy" ]]; then
|
|
if [[ "$warned" -eq 0 ]]; then
|
|
echo "AVISO: las siguientes sesiones estan BUSY y se reiniciaran; perderan el turno en vuelo"
|
|
echo " (al reanudar con --resume se recupera hasta el ultimo mensaje completo guardado):"
|
|
warned=1
|
|
fi
|
|
echo " - PID ${plan_pid[$i]} cwd=${plan_cwd[$i]}"
|
|
fi
|
|
done
|
|
[[ "$warned" -eq 1 ]] && echo
|
|
fi
|
|
|
|
# -----------------------------------------------------------------------
|
|
# DRY-RUN: parar aqui.
|
|
# -----------------------------------------------------------------------
|
|
if [[ "$mode" == "dry" ]]; then
|
|
echo "DRY-RUN: no se ha matado ni relanzado nada."
|
|
echo "Para ejecutar de verdad: reboot_all_claudes --go"
|
|
return 0
|
|
fi
|
|
|
|
if [[ "$act_count" -eq 0 ]]; then
|
|
echo "reboot_all_claudes: nada que hacer (todas las sesiones quedaron omitidas)."
|
|
return 0
|
|
fi
|
|
|
|
# -----------------------------------------------------------------------
|
|
# MODO --go: construir un script desacoplado que mata las ventanas y
|
|
# relanza las sesiones. Se ejecuta con setsid para que sobreviva al cierre
|
|
# de la propia terminal (que es una de las victimas).
|
|
# -----------------------------------------------------------------------
|
|
local ts script log
|
|
ts="$(date +%s)"
|
|
script="/tmp/reboot_all_claudes.$$.$ts.sh"
|
|
log="/tmp/reboot_all_claudes.$ts.log"
|
|
|
|
{
|
|
echo '#!/usr/bin/env bash'
|
|
echo 'set -uo pipefail'
|
|
echo '# Dar tiempo a que la terminal padre devuelva el control antes de matar.'
|
|
echo 'sleep 1'
|
|
echo
|
|
for ((i = 0; i < total; i++)); do
|
|
[[ "${plan_skip[$i]}" -eq 1 ]] && continue
|
|
local kp="${plan_kitty[$i]}"
|
|
local cp="${plan_pid[$i]}"
|
|
local cwd="${plan_cwd[$i]}"
|
|
local cmd="${plan_cmd[$i]}"
|
|
echo "# --- sesion PID ${cp} (kitty ${kp:-none}) ---"
|
|
if [[ -n "$kp" ]]; then
|
|
# Cerrar la ventana kitty limpia con SIGTERM.
|
|
echo "kill $(printf '%q' "$kp") 2>/dev/null || true"
|
|
else
|
|
# Sin kitty: matar el propio claude.
|
|
echo "kill $(printf '%q' "$cp") 2>/dev/null || true"
|
|
fi
|
|
# Relanzar en una kitty nueva, detached, en el cwd correcto.
|
|
# zsh -ic '...; exec zsh' replica el patron del usuario: al salir de
|
|
# claude queda una shell interactiva viva.
|
|
printf 'setsid kitty --directory %q zsh -ic %q </dev/null >/dev/null 2>&1 &\n' \
|
|
"$cwd" "${cmd}; exec zsh"
|
|
echo
|
|
done
|
|
echo 'exit 0'
|
|
} > "$script"
|
|
|
|
chmod +x "$script"
|
|
echo "reboot_all_claudes: lanzando plan desacoplado -> $script (log: $log)"
|
|
setsid bash "$script" </dev/null >>"$log" 2>&1 &
|
|
disown 2>/dev/null || true
|
|
echo "reboot_all_claudes: hecho. Las terminales se cerraran y reabriran en ~1s."
|
|
return 0
|
|
}
|
|
|
|
# Permitir ejecutar el archivo directamente (no solo como funcion sourced).
|
|
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
|
|
reboot_all_claudes "$@"
|
|
fi
|