JoseviandClaude Sonnet 5
1994f7b030
notify-send depende de la sesión gráfica -- poco fiable justo cuando push falla en ExecStop durante el apagado (sesión/D-Bus cayéndose). notify_fail() ahora también hace POST a push.josevi.ovh (mismo Gotify que ya usa WUD para avisos de actualizaciones), best-effort con timeout corto, leyendo el token de ~/.config/pkgsync/gotify.env -- fichero local-only, nunca tracked (mismo criterio que overrides.local.toml), con scaffold comentado en bootstrap. De paso: durante la verificación se descubrió que notify-send llevaba tiempo fallando en silencio en esta máquina (applet de Notifications ausente de shownItems/extraItems en el systray) -- arreglado aparte, no es parte de este commit. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
555 lines
22 KiB
Bash
555 lines
22 KiB
Bash
#!/usr/bin/env bash
|
|
# pkgsync: sincroniza qué paquetes (pacman + AUR + flatpak) hay instalados
|
|
# entre las dos máquinas, usando shared/packages-common.sh (en un clon propio
|
|
# del repo arch-setup) como fuente de verdad y metapac como motor de
|
|
# diff/aplicación. Mismo patrón que chezmoi-boot-sync.sh/chezmoi-shutdown-sync.sh
|
|
# (repo arch-configs) pero para paquetes en vez de dotfiles.
|
|
#
|
|
# pkgsync.sh bootstrap instala metapac + config, primera vez o retrofit
|
|
# pkgsync.sh push captura inventario real -> arrays -> commit+push (pkgsync-push.service)
|
|
# pkgsync.sh pull git pull + diff + notifica, NO instala/desinstala (pkgsync-pull.service)
|
|
# pkgsync.sh diff como pull pero solo imprime, sin tocar git ni notificar
|
|
# pkgsync.sh apply metapac sync + metapac clean, ambos con confirmación interactiva
|
|
# pkgsync.sh log [--patch]
|
|
# pkgsync.sh incoming
|
|
# pkgsync.sh audit
|
|
set -uo pipefail
|
|
|
|
REPO_URL="https://gitea.josevi.ovh/josevi/arch-setup.git"
|
|
REPO_DIR="$HOME/.local/share/arch-setup"
|
|
LOG="$HOME/.local/share/pkgsync.log"
|
|
|
|
METAPAC_CONFIG_DIR="$HOME/.config/metapac"
|
|
METAPAC_GROUP="$METAPAC_CONFIG_DIR/groups/arch-setup.toml"
|
|
OVERRIDES_FILE="$METAPAC_CONFIG_DIR/groups/overrides.local.toml"
|
|
|
|
# Marca que un push falló. pull la revisa al arrancar (con la sesión gráfica
|
|
# ya arriba) para avisar aunque el notify-send del propio push, disparado
|
|
# durante el apagado con la sesión cayéndose, no llegara a mostrarse. Se
|
|
# borra en el primer push que vuelve a tener éxito.
|
|
FAIL_MARKER="$HOME/.local/share/pkgsync.failed"
|
|
|
|
# Token de Gotify (push.josevi.ovh, mismo servidor que usa WUD) para avisos
|
|
# de fallo -- llega también sin sesión gráfica, a diferencia de notify-send.
|
|
# Fichero local-only, nunca tracked (ni chezmoi ni el repo arch-setup):
|
|
# mismo criterio que OVERRIDES_FILE. Si no existe, se omite sin más.
|
|
GOTIFY_ENV="$HOME/.config/pkgsync/gotify.env"
|
|
|
|
# flatpak sin --user/--system instala en "system" con la config actual de
|
|
# install_flatpaks() en packages-common.sh. Si tu máquina usa --user, cambia
|
|
# esto (o verifica con: flatpak list --columns=installation,application).
|
|
FLATPAK_INSTALLATION="system"
|
|
|
|
# Paquetes que NUNCA se borran automáticamente, pase lo que pase en el array
|
|
# en un momento dado -- red de seguridad independiente, para que sobreviva
|
|
# aunque el array se corrompa por error humano. Confirmada con el usuario
|
|
# 2026-08-18 (kernel/arranque, gráficos, red de rollback btrfs, y todo lo que
|
|
# sea soporte de hardware: CPU/energía, audio, bluetooth, red física, USB).
|
|
CRITICAL_PACKAGES=(
|
|
linux linux-lts linux-lts-headers linux-firmware grub efibootmgr amd-ucode
|
|
mesa vulkan-icd-loader vulkan-radeon vulkan-intel intel-media-driver
|
|
btrfs-progs snapper snap-pac grub-btrfs inotify-tools zram-generator
|
|
cpupower power-profiles-daemon
|
|
pipewire pipewire-alsa pipewire-jack pipewire-pulse wireplumber libpulse
|
|
gst-plugin-pipewire gst-plugins-good gst-plugins-bad gst-libav sof-firmware
|
|
bluez bluez-utils
|
|
networkmanager wpa_supplicant
|
|
smartmontools usbutils gvfs-mtp
|
|
)
|
|
|
|
# --- inventario real ---------------------------------------------------------
|
|
installed_pacman_native() { pacman -Qqen 2>/dev/null; } # explícitos de repos oficiales
|
|
installed_pacman_foreign() { pacman -Qqem 2>/dev/null; } # explícitos AUR/locales
|
|
installed_flatpak() {
|
|
command -v flatpak &>/dev/null || return 0
|
|
flatpak list --app --columns=application 2>/dev/null
|
|
}
|
|
|
|
# --- arrays declarados (leídos del clon en $REPO_DIR) -----------------------
|
|
# Sourcea packages-common.sh en un subshell: solo lee los arrays, nunca llama
|
|
# a los install_*.
|
|
declared_array() {
|
|
local name="$1"
|
|
( source "$REPO_DIR/shared/packages-common.sh" 2>/dev/null
|
|
case "$name" in
|
|
PACMAN_COMMON) printf '%s\n' "${PACMAN_COMMON[@]}" ;;
|
|
AUR_COMMON) printf '%s\n' "${AUR_COMMON[@]}" ;;
|
|
FLATPAK_COMMON) printf '%s\n' "${FLATPAK_COMMON[@]}" ;;
|
|
esac )
|
|
}
|
|
|
|
# Paquetes en el override local (parser mínimo: basta para sacar los
|
|
# packages = [...] de [arch] y [flatpak], ignorando líneas comentadas).
|
|
overrides_packages() {
|
|
[[ -f "$OVERRIDES_FILE" ]] || return 0
|
|
awk '
|
|
/^[[:space:]]*#/ { next }
|
|
/packages[[:space:]]*=[[:space:]]*\[/ { inarr=1 }
|
|
inarr {
|
|
while (match($0, /"[^"]+"/)) {
|
|
print substr($0, RSTART+1, RLENGTH-2)
|
|
$0 = substr($0, RSTART+RLENGTH)
|
|
}
|
|
}
|
|
/\]/ { inarr=0 }
|
|
' "$OVERRIDES_FILE"
|
|
}
|
|
|
|
# --- parcheo del array en packages-common.sh sin tocar comentarios ----------
|
|
# Quita de $array_name los tokens listados en $remove_list (uno por línea) y
|
|
# añade los de $add_list en un bloque marcador al final, dejando el resto de
|
|
# líneas (incluidos los comentarios de agrupación) intactas.
|
|
patch_array_file() {
|
|
local file="$1" array_name="$2" remove_list="$3" add_list="$4"
|
|
local marker=" # --- pkgsync: nuevos detectados (revisa y reorganiza a mano) ---"
|
|
|
|
local -A to_remove=()
|
|
local pkg
|
|
while IFS= read -r pkg; do
|
|
[[ -n "$pkg" ]] && to_remove["$pkg"]=1
|
|
done <<<"$remove_list"
|
|
|
|
local -a lines
|
|
mapfile -t lines <"$file"
|
|
|
|
local start_idx=-1 end_idx=-1 i
|
|
for i in "${!lines[@]}"; do
|
|
if [[ "${lines[$i]}" == "${array_name}=(" ]]; then start_idx=$i; break; fi
|
|
done
|
|
if (( start_idx < 0 )); then
|
|
echo "!! no encuentro el array $array_name en $file" >&2
|
|
return 1
|
|
fi
|
|
for ((i = start_idx + 1; i < ${#lines[@]}; i++)); do
|
|
if [[ "${lines[$i]}" == ")" ]]; then end_idx=$i; break; fi
|
|
done
|
|
if (( end_idx < 0 )); then
|
|
echo "!! no encuentro el cierre de $array_name en $file" >&2
|
|
return 1
|
|
fi
|
|
|
|
# Ojo: las líneas de paquetes que quedaron bajo el marcador de una pasada
|
|
# anterior NO se descartan aquí -- pasan por el mismo filtro de to_remove
|
|
# que cualquier otra línea, así que lo que ya se añadió sigue en el array
|
|
# aunque esta pasada no tenga nada nuevo que añadir (add_list vacío). Solo
|
|
# se quita la línea de comentario del marcador en sí, para no acumular
|
|
# comentarios duplicados; si hay contenido nuevo se vuelve a escribir abajo.
|
|
local -a new_body=()
|
|
for ((i = start_idx + 1; i < end_idx; i++)); do
|
|
local line="${lines[$i]}"
|
|
if [[ "$line" == "$marker" ]]; then continue; fi
|
|
if [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]]; then
|
|
new_body+=("$line")
|
|
continue
|
|
fi
|
|
local indent="${line%%[^[:space:]]*}"
|
|
local -a tokens=($line)
|
|
local -a kept=()
|
|
local t
|
|
for t in "${tokens[@]}"; do
|
|
[[ -n "${to_remove[$t]:-}" ]] || kept+=("$t")
|
|
done
|
|
(( ${#kept[@]} > 0 )) && new_body+=("${indent}${kept[*]}")
|
|
done
|
|
|
|
if [[ -n "$add_list" ]]; then
|
|
new_body+=("$marker")
|
|
local p
|
|
while IFS= read -r p; do
|
|
[[ -n "$p" ]] && new_body+=(" $p")
|
|
done <<<"$add_list"
|
|
fi
|
|
|
|
local tmp
|
|
tmp="$(mktemp)"
|
|
printf '%s\n' "${lines[@]:0:start_idx+1}" "${new_body[@]}" "${lines[@]:end_idx}" >"$tmp"
|
|
mv "$tmp" "$file"
|
|
}
|
|
|
|
# --- group file de metapac ---------------------------------------------------
|
|
# Regenerado en bootstrap/push/pull. Fuerza la unión con CRITICAL_PACKAGES: es
|
|
# la segunda capa de protección, para que metapac nunca vea esos paquetes como
|
|
# "no declarados" aunque el array se corrompiera.
|
|
write_group_file() {
|
|
mkdir -p "$(dirname "$METAPAC_GROUP")"
|
|
{
|
|
echo "# generado por pkgsync -- no editar a mano, se sobreescribe en cada bootstrap/push/pull"
|
|
echo "[arch]"
|
|
echo "packages = ["
|
|
{ declared_array PACMAN_COMMON; declared_array AUR_COMMON; printf '%s\n' "${CRITICAL_PACKAGES[@]}"; } \
|
|
| sort -u | while IFS= read -r p; do [[ -n "$p" ]] && printf ' "%s",\n' "$p"; done
|
|
echo "]"
|
|
echo
|
|
echo "[flatpak]"
|
|
echo "packages = ["
|
|
declared_array FLATPAK_COMMON | sort -u | while IFS= read -r p; do
|
|
[[ -n "$p" ]] && printf ' { name = "%s:%s", options = { remote = "flathub" } },\n' "$FLATPAK_INSTALLATION" "$p"
|
|
done
|
|
echo "]"
|
|
} >"$METAPAC_GROUP"
|
|
}
|
|
|
|
# --- diff declarado vs instalado --------------------------------------------
|
|
# Deja el resultado en arrays globales: TO_INSTALL_* (declarado, no instalado)
|
|
# y TO_REVIEW_REMOVE_* (instalado, no declarado).
|
|
compute_diff() {
|
|
local work
|
|
work="$(mktemp -d)"
|
|
|
|
{ declared_array PACMAN_COMMON; declared_array AUR_COMMON; printf '%s\n' "${CRITICAL_PACKAGES[@]}"; } | sort -u >"$work/declared_arch"
|
|
declared_array FLATPAK_COMMON | sort -u >"$work/declared_flatpak"
|
|
overrides_packages | sort -u >"$work/overrides"
|
|
{ installed_pacman_native; installed_pacman_foreign; } | sort -u >"$work/installed_arch"
|
|
installed_flatpak | sort -u >"$work/installed_flatpak"
|
|
|
|
mapfile -t TO_INSTALL_ARCH < <(comm -23 "$work/declared_arch" "$work/installed_arch" | comm -23 - "$work/overrides")
|
|
mapfile -t TO_REVIEW_REMOVE_ARCH < <(comm -13 "$work/declared_arch" "$work/installed_arch" | comm -23 - "$work/overrides")
|
|
mapfile -t TO_INSTALL_FLATPAK < <(comm -23 "$work/declared_flatpak" "$work/installed_flatpak" | comm -23 - "$work/overrides")
|
|
mapfile -t TO_REVIEW_REMOVE_FLATPAK < <(comm -13 "$work/declared_flatpak" "$work/installed_flatpak" | comm -23 - "$work/overrides")
|
|
|
|
rm -rf "$work"
|
|
}
|
|
|
|
print_list() {
|
|
if (( $# == 0 )); then echo " (nada)"; return; fi
|
|
printf ' %s\n' "$@"
|
|
}
|
|
|
|
print_diff() {
|
|
echo "== pendiente de instalar (declarado, no instalado) =="
|
|
print_list "${TO_INSTALL_ARCH[@]}" "${TO_INSTALL_FLATPAK[@]}"
|
|
echo
|
|
echo "== instalado pero no declarado (candidato a revisar/borrar con 'pkgsync apply') =="
|
|
print_list "${TO_REVIEW_REMOVE_ARCH[@]}" "${TO_REVIEW_REMOVE_FLATPAK[@]}"
|
|
}
|
|
|
|
notify() {
|
|
# timeout: notify-send puede colgarse activando por D-Bus el servicio de
|
|
# notificaciones si algo va raro en la sesión -- que eso nunca bloquee el
|
|
# pull entero (nos pasó una vez: se comió los 60s de TimeoutStartSec del
|
|
# servicio systemd y lo mató).
|
|
command -v notify-send &>/dev/null && timeout 5 notify-send --app-name=pkgsync "$1" "$2"
|
|
}
|
|
|
|
# Como notify(), pero urgencia "critical" (se queda en pantalla hasta que se
|
|
# cierra a mano) y además deja constancia en $FAIL_MARKER: push corre en
|
|
# ExecStop durante el apagado, con la sesión/D-Bus ya cayéndose, así que su
|
|
# notify-send puede no llegar a mostrarse -- el marcador es la red de
|
|
# seguridad que garantiza el aviso en el siguiente pull, ya con la sesión
|
|
# gráfica completa.
|
|
notify_fail() {
|
|
echo "!! $1: $2" >&2
|
|
printf '%s -- %s: %s\n' "$(date -Iseconds)" "$1" "$2" >"$FAIL_MARKER"
|
|
command -v notify-send &>/dev/null && timeout 5 notify-send --app-name=pkgsync --urgency=critical "$1" "$2"
|
|
notify_gotify "$1" "$2"
|
|
}
|
|
|
|
# Best-effort, nunca bloquea ni hace fallar el caller: mismo espíritu que el
|
|
# timeout de notify-send de arriba, pero via HTTPS -- llega aunque D-Bus/la
|
|
# sesión gráfica ya esté cayéndose (caso ExecStop en apagado) o no haya
|
|
# sesión gráfica en absoluto.
|
|
notify_gotify() {
|
|
[[ -f "$GOTIFY_ENV" ]] || return 0
|
|
local GOTIFY_URL GOTIFY_TOKEN
|
|
# shellcheck disable=SC1090
|
|
source "$GOTIFY_ENV"
|
|
[[ -n "${GOTIFY_URL:-}" && -n "${GOTIFY_TOKEN:-}" ]] || return 0
|
|
timeout 10 curl -fsS --max-time 8 \
|
|
-F "title=$1" -F "message=$2" -F "priority=8" \
|
|
"${GOTIFY_URL%/}/message?token=${GOTIFY_TOKEN}" >/dev/null 2>&1
|
|
}
|
|
|
|
# --- subcomandos --------------------------------------------------------------
|
|
cmd_bootstrap() {
|
|
echo ">> pkgsync bootstrap"
|
|
|
|
if ! command -v metapac &>/dev/null; then
|
|
echo ">> instalando metapac (AUR)..."
|
|
if command -v paru &>/dev/null; then
|
|
paru -S --needed --noconfirm metapac
|
|
else
|
|
echo "!! no encuentro paru; instala metapac a mano (helper AUR) y vuelve a correr 'pkgsync bootstrap'." >&2
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
mkdir -p "$METAPAC_CONFIG_DIR/groups" "$(dirname "$REPO_DIR")" "$(dirname "$LOG")"
|
|
|
|
if [[ ! -f "$METAPAC_CONFIG_DIR/config.toml" ]]; then
|
|
cat >"$METAPAC_CONFIG_DIR/config.toml" <<'EOF'
|
|
enabled_backends = ["arch", "flatpak"]
|
|
|
|
[arch]
|
|
package_manager = "paru"
|
|
EOF
|
|
echo ">> $METAPAC_CONFIG_DIR/config.toml creado"
|
|
fi
|
|
|
|
if [[ ! -f "$OVERRIDES_FILE" ]]; then
|
|
cat >"$OVERRIDES_FILE" <<'EOF'
|
|
# Paquetes que SOLO tienen sentido en ESTA máquina.
|
|
#
|
|
# pkgsync nunca lee ni escribe este fichero de forma automática: no vive en
|
|
# el repo arch-setup, no viaja a la otra máquina. metapac sí lo combina con
|
|
# el resto de group files de ~/.config/metapac/groups/ para sus propios
|
|
# sync/clean, así que un paquete puesto aquí queda protegido de 'pkgsync
|
|
# apply' igual que si estuviera en el array compartido.
|
|
#
|
|
# Descomenta y edita, por ejemplo:
|
|
#
|
|
# [arch]
|
|
# packages = ["algun-paquete-solo-de-esta-maquina"]
|
|
#
|
|
# [flatpak]
|
|
# packages = ["system:com.algo.SoloAqui"]
|
|
EOF
|
|
echo ">> scaffold de $OVERRIDES_FILE creado (vacío, edítalo a mano)"
|
|
fi
|
|
|
|
if [[ ! -f "$GOTIFY_ENV" ]]; then
|
|
mkdir -p "$(dirname "$GOTIFY_ENV")"
|
|
cat >"$GOTIFY_ENV" <<'EOF'
|
|
# Token de aplicación Gotify para los avisos de fallo de pkgsync (push.josevi.ovh).
|
|
# Crea una Application nueva en la UI de Gotify y pega su token aquí.
|
|
# Fichero local-only: pkgsync nunca lo lee/escribe salvo aquí, no viaja al repo.
|
|
#GOTIFY_URL="https://push.josevi.ovh"
|
|
#GOTIFY_TOKEN="pon-aqui-el-token"
|
|
EOF
|
|
chmod 600 "$GOTIFY_ENV"
|
|
echo ">> scaffold de $GOTIFY_ENV creado (comentado, edítalo a mano para activar avisos por Gotify)"
|
|
fi
|
|
|
|
if [[ ! -d "$REPO_DIR/.git" ]]; then
|
|
echo ">> clonando arch-setup en $REPO_DIR..."
|
|
git clone "$REPO_URL" "$REPO_DIR"
|
|
fi
|
|
|
|
write_group_file
|
|
echo ">> bootstrap completo. Activa los servicios con:"
|
|
echo " systemctl --user enable --now pkgsync-push.service pkgsync-pull.service"
|
|
}
|
|
|
|
cmd_push() {
|
|
mkdir -p "$(dirname "$LOG")"
|
|
exec >>"$LOG" 2>&1
|
|
echo "=== push $(date -Iseconds) ==="
|
|
|
|
if [[ ! -d "$REPO_DIR/.git" ]]; then
|
|
notify_fail "pkgsync: push falló" "no existe el clon $REPO_DIR, corre 'pkgsync bootstrap'"
|
|
return 0
|
|
fi
|
|
|
|
local work
|
|
work="$(mktemp -d)"
|
|
|
|
installed_pacman_native | sort -u >"$work/inst_native"
|
|
installed_pacman_foreign | sort -u >"$work/inst_foreign"
|
|
cat "$work/inst_native" "$work/inst_foreign" | sort -u >"$work/inst_arch_any"
|
|
installed_flatpak | sort -u >"$work/inst_flatpak"
|
|
overrides_packages | sort -u >"$work/overrides"
|
|
printf '%s\n' "${CRITICAL_PACKAGES[@]}" | sort -u >"$work/critical"
|
|
|
|
declared_array PACMAN_COMMON | sort -u >"$work/decl_pacman"
|
|
declared_array AUR_COMMON | sort -u >"$work/decl_aur"
|
|
declared_array FLATPAK_COMMON | sort -u >"$work/decl_flatpak"
|
|
cat "$work/decl_pacman" "$work/decl_aur" | sort -u >"$work/decl_arch_any"
|
|
|
|
comm -23 "$work/critical" "$work/inst_arch_any" | while IFS= read -r c; do
|
|
[[ -n "$c" ]] && echo "!! AVISO: paquete crítico '$c' no está instalado localmente; se mantiene declarado (no se toca)"
|
|
done
|
|
|
|
local remove_pacman add_pacman remove_aur add_aur remove_flatpak add_flatpak
|
|
remove_pacman="$(comm -23 "$work/decl_pacman" "$work/inst_arch_any" | comm -23 - "$work/overrides" | comm -23 - "$work/critical")"
|
|
add_pacman="$(comm -23 "$work/inst_native" "$work/decl_arch_any" | comm -23 - "$work/overrides")"
|
|
remove_aur="$(comm -23 "$work/decl_aur" "$work/inst_arch_any" | comm -23 - "$work/overrides" | comm -23 - "$work/critical")"
|
|
add_aur="$(comm -23 "$work/inst_foreign" "$work/decl_arch_any" | comm -23 - "$work/overrides")"
|
|
remove_flatpak="$(comm -23 "$work/decl_flatpak" "$work/inst_flatpak" | comm -23 - "$work/overrides" | comm -23 - "$work/critical")"
|
|
add_flatpak="$(comm -23 "$work/inst_flatpak" "$work/decl_flatpak" | comm -23 - "$work/overrides")"
|
|
|
|
local pc="$REPO_DIR/shared/packages-common.sh"
|
|
local patch_failed=0
|
|
patch_array_file "$pc" PACMAN_COMMON "$remove_pacman" "$add_pacman" || patch_failed=1
|
|
patch_array_file "$pc" AUR_COMMON "$remove_aur" "$add_aur" || patch_failed=1
|
|
patch_array_file "$pc" FLATPAK_COMMON "$remove_flatpak" "$add_flatpak" || patch_failed=1
|
|
|
|
rm -rf "$work"
|
|
|
|
# No commitear nunca un parcheo a medias/fallido -- así fue como el fichero
|
|
# acabó vacío en origin/main una vez (2026-08-27): el parcheo falló pero el
|
|
# script siguió y commiteó igualmente lo que hubiera en disco. El fichero
|
|
# de trabajo no se toca cuando patch_array_file falla (solo escribe si
|
|
# encuentra el array), así que abortar aquí es seguro: el próximo intento
|
|
# vuelve a partir del mismo estado.
|
|
if (( patch_failed )); then
|
|
notify_fail "pkgsync: push falló" "no se pudo parchear packages-common.sh (arrays no encontrados), reviso sin commitear -- $LOG"
|
|
return 1
|
|
fi
|
|
|
|
write_group_file
|
|
|
|
cd "$REPO_DIR" || return 0
|
|
git add shared/packages-common.sh
|
|
if git diff --cached --quiet; then
|
|
echo "sin cambios de paquetes que subir"
|
|
rm -f "$FAIL_MARKER"
|
|
return 0
|
|
fi
|
|
|
|
git commit -m "pkgsync: actualiza inventario de paquetes $(date '+%Y-%m-%d %H:%M')"
|
|
if timeout 20 git push origin main; then
|
|
echo "push OK"
|
|
rm -f "$FAIL_MARKER"
|
|
else
|
|
notify_fail "pkgsync: push falló" "commit local OK pero 'git push' falló (¿sin red?); el commit queda en local para el próximo intento"
|
|
fi
|
|
}
|
|
|
|
cmd_pull() {
|
|
mkdir -p "$(dirname "$LOG")"
|
|
exec >>"$LOG" 2>&1
|
|
echo "=== pull $(date -Iseconds) ==="
|
|
|
|
# Red de seguridad: si un push anterior falló (típicamente en ExecStop
|
|
# durante el apagado, con la sesión/D-Bus ya cayéndose y su propio
|
|
# notify-send sin garantía de mostrarse), avisar aquí sí o sí -- pull corre
|
|
# al arrancar sesión, con el escritorio ya completo.
|
|
if [[ -f "$FAIL_MARKER" ]]; then
|
|
notify_fail "pkgsync: hay un fallo pendiente de revisar" "$(cat "$FAIL_MARKER")"
|
|
fi
|
|
|
|
if ! timeout 15 git ls-remote --exit-code "$REPO_URL" &>/dev/null; then
|
|
echo "sin conexión con el remoto, me quedo con el estado local"
|
|
elif [[ ! -d "$REPO_DIR/.git" ]]; then
|
|
echo "clonando arch-setup en $REPO_DIR..."
|
|
mkdir -p "$(dirname "$REPO_DIR")"
|
|
if timeout 30 git clone "$REPO_URL" "$REPO_DIR"; then
|
|
echo "clon inicial OK"
|
|
else
|
|
notify_fail "pkgsync: pull falló" "no se pudo clonar $REPO_URL, revisa $LOG"
|
|
fi
|
|
else
|
|
if timeout 30 git -C "$REPO_DIR" pull --ff-only origin main; then
|
|
echo "git pull OK"
|
|
else
|
|
# ls-remote de arriba ya confirmó que hay red -- esto es un conflicto
|
|
# real (fast-forward imposible), no un simple "sin conexión".
|
|
notify_fail "pkgsync: pull falló" "'git pull --ff-only' falló (conflicto local, revisa $REPO_DIR a mano); sigo con el estado que haya"
|
|
fi
|
|
fi
|
|
|
|
if [[ ! -d "$REPO_DIR/.git" ]]; then
|
|
echo "no hay clon de arch-setup, no puedo calcular diff"
|
|
return 0
|
|
fi
|
|
|
|
write_group_file
|
|
compute_diff
|
|
|
|
local n_install=$(( ${#TO_INSTALL_ARCH[@]} + ${#TO_INSTALL_FLATPAK[@]} ))
|
|
local n_remove=$(( ${#TO_REVIEW_REMOVE_ARCH[@]} + ${#TO_REVIEW_REMOVE_FLATPAK[@]} ))
|
|
|
|
print_diff
|
|
|
|
if (( n_install == 0 && n_remove == 0 )); then
|
|
echo "sin cambios pendientes"
|
|
else
|
|
notify "pkgsync: cambios de paquetes pendientes" \
|
|
"$n_install a instalar, $n_remove a revisar para borrar. Detalle: pkgsync diff (o $LOG)"
|
|
fi
|
|
|
|
if [[ "${PKGSYNC_AUTO_INSTALL:-0}" == "1" ]] && (( n_install > 0 )); then
|
|
echo "PKGSYNC_AUTO_INSTALL=1: instalando automáticamente lo que falta (nunca borra)"
|
|
metapac sync --no-confirm
|
|
fi
|
|
}
|
|
|
|
cmd_apply() {
|
|
echo ">> pkgsync apply: metapac sync (instalar) + metapac clean (borrar, con confirmación)"
|
|
[[ -d "$REPO_DIR/.git" ]] || { echo "!! no existe $REPO_DIR, corre 'pkgsync bootstrap' primero"; return 1; }
|
|
write_group_file
|
|
metapac sync
|
|
metapac clean
|
|
}
|
|
|
|
cmd_log() {
|
|
[[ -d "$REPO_DIR/.git" ]] || { echo "!! no hay clon en $REPO_DIR, corre 'pkgsync bootstrap' primero"; return 1; }
|
|
if [[ "${1:-}" == "--patch" ]]; then
|
|
git -C "$REPO_DIR" log --follow -p -- shared/packages-common.sh
|
|
else
|
|
git -C "$REPO_DIR" log --follow --stat -- shared/packages-common.sh
|
|
fi
|
|
}
|
|
|
|
cmd_incoming() {
|
|
[[ -d "$REPO_DIR/.git" ]] || { echo "!! no hay clon en $REPO_DIR, corre 'pkgsync bootstrap' primero"; return 1; }
|
|
git -C "$REPO_DIR" fetch --quiet origin
|
|
local n
|
|
n="$(git -C "$REPO_DIR" log HEAD..origin/main --oneline | wc -l)"
|
|
if (( n == 0 )); then
|
|
echo "sin commits nuevos en origin/main"
|
|
else
|
|
echo "$n commit(s) nuevos en origin/main:"
|
|
git -C "$REPO_DIR" log HEAD..origin/main --oneline
|
|
fi
|
|
}
|
|
|
|
cmd_audit() {
|
|
local work
|
|
work="$(mktemp -d)"
|
|
|
|
{ declared_array PACMAN_COMMON; declared_array AUR_COMMON; printf '%s\n' "${CRITICAL_PACKAGES[@]}"; overrides_packages; } | sort -u >"$work/declared_arch"
|
|
{ declared_array FLATPAK_COMMON; overrides_packages; } | sort -u >"$work/declared_flatpak"
|
|
|
|
installed_pacman_native | sort -u >"$work/inst_native"
|
|
installed_pacman_foreign | sort -u >"$work/inst_foreign"
|
|
installed_flatpak | sort -u >"$work/inst_flatpak"
|
|
|
|
echo "== pacman (oficiales) instalados, no declarados en ningún array =="
|
|
comm -23 "$work/inst_native" "$work/declared_arch"
|
|
echo
|
|
echo "== AUR/foráneos instalados, no declarados en ningún array =="
|
|
comm -23 "$work/inst_foreign" "$work/declared_arch"
|
|
echo
|
|
echo "== flatpaks instalados, no declarados =="
|
|
comm -23 "$work/inst_flatpak" "$work/declared_flatpak"
|
|
echo
|
|
echo "(nota: los paquetes específicos de KDE hardcodeados en kde/setup.sh"
|
|
echo " -- plasma-desktop, sddm, temas AUR, etc. -- siempre van a salir aquí: no"
|
|
echo " viven en los arrays de packages-common.sh por diseño, no es drift real)"
|
|
|
|
rm -rf "$work"
|
|
}
|
|
|
|
usage() {
|
|
cat >&2 <<'EOF'
|
|
uso: pkgsync.sh <bootstrap|push|pull|diff|apply|log|incoming|audit>
|
|
|
|
bootstrap instala metapac + config + clon local (primera vez / retrofit)
|
|
push captura el inventario real y lo sube al repo (usa pkgsync-push.service)
|
|
pull git pull + calcula diff + notifica; NO instala ni desinstala nada (usa pkgsync-pull.service)
|
|
diff como pull pero solo imprime el diff, sin tocar git ni notificar
|
|
apply aplica lo pendiente con metapac (sync + clean), pidiendo confirmación
|
|
log [--patch] historial de shared/packages-common.sh
|
|
incoming commits nuevos en origin/main aún no traídos
|
|
audit paquetes instalados localmente que no están declarados en ningún sitio
|
|
EOF
|
|
}
|
|
|
|
main() {
|
|
local cmd="${1:-}"
|
|
[[ $# -gt 0 ]] && shift
|
|
case "$cmd" in
|
|
bootstrap) cmd_bootstrap ;;
|
|
push) cmd_push ;;
|
|
pull) cmd_pull ;;
|
|
diff) compute_diff; print_diff ;;
|
|
apply) cmd_apply ;;
|
|
log) cmd_log "$@" ;;
|
|
incoming) cmd_incoming ;;
|
|
audit) cmd_audit ;;
|
|
*) usage; return 1 ;;
|
|
esac
|
|
}
|
|
|
|
main "$@"
|