Skip to main content

📩 Tweaks fĂŒr Manjaro

tweaksManjaro.sh – Terminal-MenĂŒversion

V25.12.020

ZIP-Archiv mit tweaksManjaro.sh und tweaksManjaro.desktop:
tweaksManjaro_V25-12-020.zip

⚠ WICHTIG
Nutzung auf eigene Verantwortung – bitte vorher Backups anlegen!

▶ Aufruf und Startoptionen

bash tweaksManjaro.sh

Alternativ:

chmod +x tweaksManjaro.sh
./tweaksManjaro.sh

Oder ĂŒber einen Desktop-Starter ausfĂŒhren
(z.B. tweaksManjaro.desktop fĂŒr KDE)

💡 Hinweis
Das Skript verwendet bei Bedarf sudo – es darf nicht direkt als root gestartet werden!

đŸ§Ÿ Beschreibung

Das Skript bietet zahlreiche System-Tweaks fĂŒr Manjaro Linux
und ersetzt die frĂŒhere KDE-Version (KDEtweaksManjaro.sh mit kdialog)
durch eine vollstÀndig terminalbasierte OberflÀche.

tweaks-manjaro.png

⭐ NEUE FUNKTIONEN ab Version V25.12.020

đŸ§© UEFI-basierte GRUB-Diagnose (automatisch & manuell)

Die GRUB-Diagnose prĂŒft vor einem Neustart, ob die Grundvoraussetzungen fĂŒr ein sauberes GRUB-Update erfĂŒllt sind:

  • Erkennt, ob das System im UEFI-Modus lĂ€uft
  • PrĂŒft zuverlĂ€ssig, ob /boot/efi korrekt eingehĂ€ngt ist
  • Erkennt typische Update-Probleme, wenn GRUB nicht vollstĂ€ndig aktualisiert wurde
  • Warnung in Rot, wenn ein Neustart zu grub rescue fĂŒhren könnte
  • Reparaturhinweise (inkl. sudo grub-install && sudo update-grub)
  • Blaues Info-Label bei Nicht-UEFI-Systemen

🏁 Automatische AusfĂŒhrung

  • Nach MenĂŒpunkt 1 – Systemupdate
  • Nach MenĂŒpunkt 2 – AUR-Update (yay)
  • Standard: aktiviert (grub_diag=1)

🔧 Manuelle AusfĂŒhrung ĂŒber MenĂŒpunkt 18
Ideal, um GRUB jederzeit zu prĂŒfen – auch ohne Update.

đŸȘ” Logging

Das integrierte Logging (steuerbar ĂŒber LOGGING=true/false)
speichert Ausgaben in der Datei tweaksManjaro-LOG.txt
neben dem Skript.

Wird die in LOG_MAX_BYTES definierte GrĂ¶ĂŸe ĂŒberschritten,
wird automatisch nach LOG_OLD_FILE rotiert.

⚙ Hauptfunktionen

  • 🔍 Kernel-Check und vollstĂ€ndige Systemaktualisierung
  • 📩 AUR-Updates ĂŒber yay
  • đŸ§č Bereinigen von Paket-Caches und Entfernen verwaister Pakete
  • 🔐 Setzen und Korrigieren von Zugriffsrechten im Home-Verzeichnis
  • đŸ’Ÿ Btrfs-Scrub starten und Status anzeigen
  • đŸ–„ïž System- und Hardwareinformationen ausgeben
  • đŸŒĄïž Sensorwerte sowie NVMe- und USB-S.M.A.R.T.-Daten anzeigen
  • 🔧 GRUB-Konfiguration aktualisieren
  • đŸ›Ąïž Entfernen von Pacman-Datenbanksperren
  • đŸȘ« SSD-Optimierung via fstrim
  • 📊 Anzeige der Speicherplatzbelegung
  • đŸ§© UEFI-basierte GRUB-Diagnose

🔑 Rechtevergabe

Variable Beschreibung
zugriffsrechte=0 Standardwert: Setzt nur Besitzerrechte (chown) rekursiv. Bestehende Dateirechte bleiben unverÀndert.
zugriffsrechte=1 ZusĂ€tzlich: chmod 755 fĂŒr Verzeichnisse und chmod 644 fĂŒr Dateien.
Ausnahme: ~/.gnupg → chmod 700 / chmod 600.

⚠ Achtung:
zugriffsrechte=1 greift tief in die Struktur des Home-Verzeichnisses ein.
Anwendungen wie Flatpaks, Tor-Browser oder Programme unter ~/.
können dadurch unbrauchbar werden.
Nutze diese Option nur, wenn du genau weißt, was du tust.

đŸ§© Weitere Hinweise

UnabhÀngig von den Einstellungen werden alle
.sh, .desktop und .AppImage-Dateien
im Home-Verzeichnis automatisch ausfĂŒhrbar gemacht (chmod 744).

💡 Dadurch wird auch dieses Skript ausfĂŒhrbar,
sofern es im Home-Verzeichnis liegt.

⭐ Zusammenfassung der GRUB-Diagnose

Feature Beschreibung
UEFI-Erkennung Erkennt zuverlÀssig, ob das System im UEFI-Modus lÀuft
EFI-Mount-Check PrĂŒft, ob /boot/efi korrekt eingehĂ€ngt war – besonders wichtig bei großen Updates
Update-IntegritÀt Erkennt typische Update-Probleme, wenn GRUB nicht richtig aktualisiert wurde
Fehlererkennung Meldet fehlende EFI-Dateien oder ein nicht eingehÀngtes /boot/efi
Reparaturhinweise Zeigt konkrete Schritte vor einem Neustart, um Boot-Probleme zu vermeiden
Automatische AusfĂŒhrung Wird nach System- und AUR-Updates automatisch ausgefĂŒhrt
Manueller Modus Über MenĂŒpunkt 18 jederzeit abrufbar

Die Diagnose hilft, Probleme zu vermeiden wie:

  • grub_memcpy not found
  • unvollstĂ€ndig aktualisierte GRUB-Installationen
  • fehlende oder beschĂ€digte EFI-Dateien
  • Update bei nicht eingehĂ€ngtem EFI

✅ Fazit

tweaksManjaro.sh ist ein leistungsfÀhiges, flexibles
und komfortables Terminal-Tool zur Pflege von Manjaro Linux.

Mit der neuen UEFI-GRUB-Diagnose erkennt das Skript jetzt auch
kritische GRUB-Probleme vor einem Neustart – insbesondere eine
nicht eingehÀngte EFI-Partition oder unvollstÀndig aktualisierte
GRUB-Installationen. Dadurch können typische Bootfehler wie
„grub rescue“ zuverlĂ€ssig vermieden und rechtzeitig korrigiert werden.

⚙ tweaksManjaro.sh

#!/bin/bash
# ------------------------------------------------------------------------
# tweaksManjaro.sh (Terminal-MenĂŒversion)
#
# WICHTIG: Nutzung auf eigene Verantwortung – bitte vorher Backups anlegen!
#
# Aufruf: bash tweaksManjaro.sh
# Alternativ: AusfĂŒhrbar machen mit chmod +x tweaksManjaro.sh und direkt starten: ./tweaksManjaro.sh
# Oder ĂŒber einen Desktop-Starter (z.B. tweaksManjaro.desktop fĂŒr KDE)
#
# Hinweis: Das Skript verwendet bei Bedarf sudo – es darf nicht direkt als root gestartet werden!
# ------------------------------------------------------------------------
# Beschreibung:
# Dieses Skript bietet verschiedene System-Tweaks fĂŒr Manjaro Linux.
# Es ersetzt die ursprĂŒngliche KDE-Version (KDEtweaksManjaro.sh mit kdialog)
# durch eine rein terminalbasierte OberflÀche.
#
# Integriertes Logging (schaltbar per LOGGING=true/false),
# speichert in tweaksManjaro-LOG.txt neben dem Script.
# Bei Überschreiten von LOG_MAX_BYTES wird nach LOG_OLD_FILE rotiert.
#
# Die wichtigsten Optionen sind:
# - Kernel-Check und Systemaktualisierung
# - AUR-Update via yay
# - AufrÀumen von Paket-Caches und verwaisten Paketen
# - Setzen von Zugriffsrechten im Home-Verzeichnis
# - Anzeige von Systeminformationen, Sensorwerten, NVMe S.M.A.R.T.
# - Btrfs-PrĂŒfung und Scrub
# - Entfernen von Pacman-Datenbanksperren
# - GRUB-Konfiguration aktualisieren
#
# NEUE FUNKTIONEN (>= V25.12.020)
# - UEFI-basierte GRUB-Diagnose (automatisch & manuell):
#     * Über MenĂŒpunkt 18 manuell ausfĂŒhrbar
#     * Optional automatisch nach Punkt 1 und 2 (System-Update / AUR-Update)
#     * Default: aktiviert (grub_diag=1)
#     * Erkennt:
#         - Ob das System UEFI nutzt
#         - Ob /boot/efi korrekt eingehÀngt ist
#     * Wenn /boot/efi nicht eingehÀngt ist:
#           → Warnung in Rot
#           → Empfehlung: 'sudo grub-install && sudo update-grub'
#           → ZusĂ€tzlich Hinweise zur manuellen Reparatur
#     * Bei UEFI-Systemen mit korrekt gemountetem /boot/efi:
#           → Info, dass GRUB korrekt aktualisiert werden kann
#     * Bei Nicht-UEFI-Systemen:
#           → Neutrale Info in Blau (Legacy/BIOS-Systeme)
#
# Hinweis zur Rechtevergabe:
# - zugriffsrechte=0: nur Besitzerrechte (chown) setzen, keine chmod-Änderungen.
# - zugriffsrechte=1: setzt chmod 755 fĂŒr Verzeichnisse, 644 fĂŒr Dateien
#   (Ausnahme: ~/.gnupg wird korrekt auf 700/600 gesetzt).
#   ACHTUNG: Flatpaks, Tor-Browser oder Anwendungen unter ~/. können dadurch
#   unbrauchbar werden.
#
# UnabhÀngig vom Schalter:
# - Alle .sh, .desktop und .AppImage-Dateien im Home werden ausfĂŒhrbar gemacht (chmod 744).
# - also auch dieses Skript, falls es im Home liegt.
# ------------------------------------------------------------------------

set -uo pipefail
# -e -> Script wird sofort beendet, sobald ein Befehl ≠0 zurĂŒckgibt,
#       darum nicht "set -euo pipefail" wegen Logs
set -o errtrace

# Skriptversion anzeigen
version="V25.12.020"

# ===== Logging Setup =====
# Logging schaltbar: true/false
LOGGING=${LOGGING:-true}
# Logdatei neben der Scriptdatei ablegen (unabhÀngig vom PWD)
LOG_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
LOG_FILE="${LOG_DIR}/tweaksManjaro-LOG.txt"
# Maximale LoggrĂ¶ĂŸe (Bytes). Standard: 20 MB
LOG_MAX_BYTES="${LOG_MAX_BYTES:-20000000}"
LOG_OLD_FILE="${LOG_DIR}/tweaksManjaro-LOG_old.txt"

rotate_log() {
    [ "${LOGGING:-}" = "true" ] || return 0
    # Wenn Logdatei zu groß ist, nach .old verschieben (ĂŒberschreiben erlaubt) und neu beginnen
    local size=0
    if [ -f "${LOG_FILE}" ]; then
        size=$(wc -c < "${LOG_FILE}" 2>/dev/null || echo 0)
    fi
    if [ "${size}" -ge "${LOG_MAX_BYTES}" ]; then
        mv -f "${LOG_FILE}" "${LOG_OLD_FILE}" 2>/dev/null || true
        : > "${LOG_FILE}"
    fi
}

_ts() { date +"%Y-%m-%d %H:%M:%S%z"; }

log_msg() {
    [ "${LOGGING:-}" = "true" ] || return 0
    rotate_log
    local msg="$*"
    printf "[%s] [%s] %s\n" "$(_ts)" "$$" "${msg}" >> "${LOG_FILE}"
}

log_start() {
    [ "${LOGGING:-}" = "true" ] || return 0
    local step="$1"
    STEP_START_EPOCH=$(date +%s)
    log_msg "START: ${step}"
}

log_end() {
    [ "${LOGGING:-}" = "true" ] || return 0
    local step="$1"
    local ec="${2:-$?}"
    local end_epoch=$(date +%s)
    local dur="-"
    if [ -n "${STEP_START_EPOCH:-}" ]; then
        dur=$(( end_epoch - STEP_START_EPOCH ))
    fi
    log_msg "END:   ${step} | exit=${ec} | duration_s=${dur}"
    unset STEP_START_EPOCH
}

on_err_trap() {
    local ec=$?
    local lineno=${BASH_LINENO[0]:-0}
    local cmd=${BASH_COMMAND:-"unknown"}
    log_msg "ERROR: ec=${ec} line=${lineno} cmd=${cmd}"
    return $ec
}

on_exit_trap() {
    local ec=$?
    if [ -n "${CURRENT_STEP_NAME:-}" ] && [ -n "${STEP_START_EPOCH:-}" ]; then
        log_end "${CURRENT_STEP_NAME}" "${ec}"
    fi
    log_msg "EXIT: script exited with ec=${ec}"
}

# Aktivieren der Traps
# WICHTIG: Nicht die bestehenden 'set -uo pipefail' Àndern
trap on_err_trap ERR
trap on_exit_trap EXIT
# ===== Ende Logging Setup =====



# Sauberer Abbruch bei STRG+C (nicht wĂ€hrend kritischer Befehle wie pacman verwenden, nutze dafĂŒr run_protected!)
cleanup() {
    echo
    if [[ -n "${rot:-}" && -n "${reset:-}" ]]; then
        echo -e "${rot}❌ Abbruch durch Benutzer${reset}"
    else
        echo "❌ Abbruch durch Benutzer"
    fi
}
trap 'cleanup; exit 130' INT
trap 'cleanup; exit 143' TERM

run_protected() {
    trap '' INT
    "$@"
    trap 'cleanup; exit 130' INT
}


# FĂŒhre einen Befehl "weich" aus: Fehler werden geloggt, terminieren aber NICHT das MenĂŒ.
run_soft() {
    # Deaktiviere -e lokal, damit wir den Exit-Code selbst prĂŒfen können
    set +e
    "$@"
    ec=$?
    set -e
    if [ $ec -ne 0 ]; then
        log_msg "WARN: run_soft: cmd='$*' exit=${ec}"
        # Nicht abbrechen: immer 0 zurĂŒckgeben
        return 0
    fi
    return 0
}
# Wie run_soft, spiegelt aber stdout/stderr ins Log (wenn LOGGING=true) und erfasst den Exitcode korrekt.
run_soft_logged() {
    set +e
    if [ "${LOGGING:-}" = "true" ]; then
        rotate_log
        "$@" 2>&1 | tee -a "${LOG_FILE}"
        ec=${PIPESTATUS[0]}
        rotate_log
    else
        "$@"
        ec=$?
    fi
    set -e
    if [ $ec -ne 0 ]; then
        log_msg "WARN: run_soft_logged: cmd='$*' exit=${ec}"
        return 0
    fi
    return 0
}

is_uefi_system() {
    # PrĂŒfen, ob efivars existiert
    if [ -d /sys/firmware/efi/efivars ]; then
        return 0   # UEFI
    else
        return 1   # BIOS/Legacy
    fi
}

# GRUB-Diagnose standardmĂ€ĂŸig aktivieren
grub_diag=1

# Automatisch aktivieren, wenn flatpak vorhanden ist
flatpak=0
if command -v flatpak &>/dev/null; then
    flatpak=1
fi

# 1 = Rechtekorrektur aktivieren – nur wenn du weißt, was du tust und den Code unten verstehst!
# 0 = deaktivieren (empfohlen)
zugriffsrechte=0

echo "➀ Dieses Skript benötigt sudo-Rechte. Bitte gib dein Passwort ein:"
sudo -v

# Farb-Variablen gegen Terminals ohne tput-Support absichern
if tput setaf 1 &>/dev/null; then
    blau=$(tput setaf 4)
    gruen=$(tput setaf 2)
    rot=$(tput setaf 1)
    gelb=$(tput setaf 3)
    reset=$(tput sgr0)
else
    blau=""
    gruen=""
    rot=""
    gelb=""
    reset=""
fi

# Skript darf nicht direkt als root oder mit sudo gestartet werden
if [ "$EUID" -eq 0 ]; then
    echo "${rot}Fehler: Bitte das Skript nicht als root oder mit sudo starten!${reset}"
    exit 1
fi

# PrĂŒfe Distribution
if ! grep -qi "manjaro" /etc/os-release; then
    echo "${rot}Nicht Manjaro – Skript wird beendet.${reset}"
    exit 0
fi

# Distro-Name extrahieren
# distro=$(grep -oP '^NAME="\K[^"]+' /etc/os-release)
distro=$(source /etc/os-release && echo "$NAME")

# Manjaro-Version
manjaro_version=$(lsb_release -r -s 2>/dev/null || echo "unbekannt")

# ArchitekturprĂŒfung
arch=$(uname -m)
case "$arch" in
    x86_64|aarch64|armv7l|i686) ;;
    *)
        echo "${rot}Nicht unterstĂŒtzte Architektur – Skript wird beendet.${reset}"
        exit 0
        ;;
esac

# Check auf public_html
if [ -d "$HOME/public_html" ]; then
    html=1
else
    html=0
fi

# Branch bestimmen (z.B. stable/testing/unstable)
branch=$(pacman-mirrors -G 2>/dev/null || echo "stable")
# echo "DEBUG: branch wurde ermittelt als '$branch'"

press_enter() {
    read -r -p "DrĂŒcke Enter zum Fortfahren..." dummy
}

pakete=(curl yay pacman-contrib lsb-release inxi lm_sensors pacman-mirrors util-linux htop btrfs-progs smartmontools nvme-cli)

# PrĂŒfen, ob NVMe-GerĂ€te vorhanden sind (robust ĂŒber lsblk oder /sys/class/nvme)
if lsblk -d -o NAME | grep -q '^nvme' || [ -e /sys/class/nvme ]; then
    pakete+=("nvme-cli")
fi

fehlend=()
for pkg in "${pakete[@]}"; do
    if ! pacman -Qi "$pkg" &>/dev/null; then
        fehlend+=("$pkg")
    fi
done

if [ ${#fehlend[@]} -gt 0 ]; then
    echo -e "\n${rot}⚠ Fehlende Pakete:${reset} ${fehlend[*]}"
    echo -e "→ Installation z.B. mit: ${gruen}sudo pacman -S --needed ${fehlend[*]}${reset}\n"
    press_enter
fi

check_grub_health() {
    echo
    echo -e "${gelb}➀ GRUB-Diagnose wird ausgefĂŒhrt...${reset}"

    # PrĂŒfen, ob System ĂŒberhaupt UEFI nutzt
    if ! is_uefi_system; then
        echo -e "${blau}INFO: Dieses System nutzt kein UEFI.${reset}"
        echo -e "${blau}GRUB-Diagnose (UEFI-only) wird ĂŒbersprungen.${reset}"
        echo "Das ist normal, wenn das System im Legacy/BIOS-Modus installiert wurde."
        return 0
    fi

    # ----------------------------
    # PrĂŒfen: Ist /boot/efi gemountet?
    # ----------------------------
    if mount | grep -q " on /boot/efi "; then
        echo -e "${gruen}✓ /boot/efi ist eingehĂ€ngt.${reset}"
        echo
        echo -e "${blau}Hinweis:${reset}"
        echo -e "${blau}Bei großen Updates wird GRUB nur dann zuverlĂ€ssig aktualisiert,${reset}"
        echo -e "${blau}wenn /boot/efi wÀhrend des Updates korrekt eingehÀngt war.${reset}"
        echo
        echo -e "${blau}Falls nach einem Update trotzdem Boot-Probleme auftreten,${reset}"
        echo -e "${blau}siehe die detaillierte Anleitung im Wiki (https://wiki.lmatrix.de).${reset}"
        echo
    else
        echo -e "${rot}✗ /boot/efi ist NICHT eingehĂ€ngt!${reset}"
        echo -e "${rot}   → GRUB wurde beim Update sehr wahrscheinlich NICHT korrekt aktualisiert.${reset}"
        echo
        echo "   Empfohlene Standard-Reparatur:"
        echo -e "   ${gelb}sudo grub-install && sudo update-grub${reset}"
        echo
        echo "   Falls das fehlschlÀgt (z.B. weil /boot/efi nicht eingehÀngt war):"
        echo -e "   ${gelb}lsblk -o NAME,SIZE,FSTYPE,MOUNTPOINT${reset}"
        echo "      → EFI-Partition suchen (meist vfat, ~300 MB, z.B. nvme0n1p1)"
        echo
        echo -e "   ${gelb}sudo mount /dev/<EFI-PARTITION> /boot/efi${reset}"
        echo -e "   ${gelb}sudo grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=manjaro${reset}"
        echo -e "   ${gelb}sudo update-grub${reset}"
        echo
        echo "   Details / vollstÀndige Anleitung findest du im Wiki (https://wiki.lmatrix.de)."
        echo
    fi
}

# Funktion: GRUB-Konfiguration aktualisieren
update_grub() {
    echo -e "\nPrĂŒfe GRUB-Konfiguration..."

    updated=0
    if [ -f /boot/grub/grub.cfg ]; then
        echo "→ Aktualisiere GRUB (BIOS)"
        sudo grub-mkconfig -o /boot/grub/grub.cfg && updated=1
    fi
    if [ -f /boot/efi/EFI/manjaro/grub.cfg ]; then
        echo "→ Aktualisiere GRUB (UEFI)"
        sudo grub-mkconfig -o /boot/efi/EFI/manjaro/grub.cfg && updated=1
    fi
    if [ "$updated" -eq 1 ]; then
        echo "${gruen}GRUB-Konfiguration erfolgreich.${reset}"
        return 0    # Erfolg
    else
        echo "${rot}Keine grub.cfg gefunden oder Fehler beim Update.${reset}"
        return 1    # Fehler / nichts aktualisiert
    fi
}

# Funktion: Flatpaks anzeigen, aktualisieren und ungenutzte entfernen
update_flatpak() {
    if [ "$flatpak" -gt 0 ] && command -v flatpak &>/dev/null; then
        echo -e "\n${gelb}➀ Installierte Flatpak-Apps:${reset}"
        app_list=$(flatpak list --app --columns=application | grep -v "Anwendungskennung")
        if [ -n "$app_list" ]; then
            echo "$app_list"
        else
            echo "Keine Flatpak-Apps gefunden."
        fi

        echo -e "\n${gelb}➀ Flatpak-Apps aktualisieren:${reset}"
        run_soft_logged flatpak update -y || echo "Fehler bei Flatpak-Update oder keine Updates verfĂŒgbar."

        echo -e "\n${gelb}➀ Ungenutzte Flatpaks entfernen:${reset}"
        if [ "${LOGGING:-}" = "true" ]; then
            flatpak_output=$(flatpak uninstall --unused -y 2>&1 | tee -a "${LOG_FILE}")
        else
            flatpak_output=$(flatpak uninstall --unused -y 2>&1)
        fi

        if [[ "$flatpak_output" == *"Nothing unused to uninstall"* ]]; then
            echo "Keine ungenutzten Flatpaks gefunden."
        else
            echo "$flatpak_output"
        fi
    fi
}

# Funktion: LTS-Kernel-Empfehlung anzeigen
propose_lts() {
    echo -e "\n${gelb}➀ LTS-Kernel-Empfehlung:${reset}"

    # PrĂŒfe, ob installierte Kernel verfĂŒgbar sind
    if [ -z "${installed[*]:-}" ]; then
        echo -e "${rot}Keine installierten Kernel erkannt – ĂŒberspringe Empfehlung.${reset}"
        return
    fi

    # LTS-Liste laden
    if ! mapfile -t lts_list < <(
        curl -fsSL "https://gitlab.manjaro.org/applications/manjaro-settings-manager/-/raw/master/src/libmsm/KernelModel.cpp" |
        awk '/<< "linux.*/ { gsub(/"|;/,"",$NF); print $NF }'
    ); then
        echo -e "${rot}Netzwerkfehler – LTS-Liste nicht geladen.${reset}"
        return
    fi

    if [ "${#lts_list[@]}" -gt 0 ]; then
        echo " → Letzter verfĂŒgbarer LTS: ${gruen}${lts_list[0]}${reset}"
        if [ "${#lts_list[@]}" -gt 1 ] && [ "${lts_list[0]}" != "${lts_list[1]}" ]; then
            echo " → Empfohlener LTS laut Manjaro: ${gelb}${lts_list[1]}${reset}"
        fi

        if [[ ! " ${installed[*]} " =~ " ${lts_list[0]} " ]]; then
            echo -e "${gelb}Hinweis:${reset} Der aktuelle LTS-Kernel (${lts_list[0]}) ist ${rot}nicht installiert${reset}."
            echo -e " → Du kannst ihn mit z.B. ${gruen}sudo mhwd-kernel -i ${lts_list[0]}${reset} installieren."
        else
            echo "✓ Empfohlener LTS-Kernel (${lts_list[0]}) ist bereits installiert."
        fi
    else
        echo "${rot}Keine gĂŒltige LTS-Liste geladen – keine Empfehlung möglich.${reset}"
    fi
}

while true; do
    clear

    echo "${gruen}"
    echo " __        __   _                            _       "
    echo " \\ \\      / /__| | ___ ___  _ __ ___   ___  | |_ ___ "
    echo "  \\ \\ /\\ / / _ \\ |/ __/ _ \\| '_ \` _ \\ / _ \\ | __/ _ \\"
    echo "   \\ V  V /  __/ | (_| (_) | | | | | |  __/ | || (_) |"
    echo "    \\_/\\_/ \\___|_|\\___\\___/|_| |_| |_|\\___|  \\__\\___/ "
    echo ""
    echo " Linux Manjaro – Systempflege"
    echo " tweaksManjaro.sh ${version}"
    echo " Distro: $distro $manjaro_version"
    echo " Bash: $BASH_VERSION"
    echo "${reset}"

    echo "${gelb}====== WartungsmenĂŒ ======${reset}"
    echo "1) Kernel prĂŒfen und System aktualisieren"
    echo "2) System ĂŒber AUR aktualisieren (yay)"
    echo "3) Verwaiste Pakete entfernen"
    echo "4) Paket-Caches vollstÀndig löschen"
    echo "5) Spiegelserver fĂŒr DE/FR/AT aktualisieren"
    echo "6) Zugriffsrechte im Home-Verzeichnis korrigieren"
    echo "7) Systeminformationen anzeigen"
    echo "8) Fehler seit letztem Boot (journalctl)"
    echo "9) Temperatur-Sensorwerte anzeigen"
    echo "10) NVMe S.M.A.R.T.-Status anzeigen"
    echo "11) USB S.M.A.R.T.-Status anzeigen"
    echo "12) Pacman-Datenbanksperre entfernen"
    echo "13) fstrim auf SSDs ausfĂŒhren"
    echo "14) Speicherplatz anzeigen (ZurĂŒck mit Taste Q)"
    echo "15) Systemmonitor htop starten (ZurĂŒck F10)"
    echo "16) Btrfs-DatenprĂŒfung (scrub) – kann dauern"
    echo "17) Btrfs-PrĂŒfstatus anzeigen"
    echo "18) GRUB-Diagnose ausfĂŒhren"
    echo "0) Beenden"
    echo ""
    read -r -p "Auswahl [0-18]: " answer
    [ "${LOGGING:-}" = "true" ] && log_msg "MENU: Auswahl=${answer}"
    case "$answer" in
        1)
            CURRENT_STEP_NAME="Punkt 1 - Kernel prĂŒfen und System aktualisieren"
            log_start "$CURRENT_STEP_NAME"
            # Kernel Check & Systemaktualisierung
            echo -e "\n${gelb}➀ KernelprĂŒfung und Systemaktualisierung gestartet...${reset}"

            # EOL-Liste laden
            if ! mapfile -t eol_list < <(
                curl -fsSL "https://forum.manjaro.org/c/announcements/${branch}-updates.rss" |
                awk -F'>| ' '/\[EOL\]/ {print $2}' | sort -u
            ); then
                echo -e "${rot}Netzwerkfehler beim Laden der EOL-Liste – ĂŒberspringe EOL-Check.${reset}"
                eol_list=()
            fi

            # installierte Kernel ermitteln
            mapfile -t installed < <(mhwd-kernel -li | awk '{print $2}' | grep '^linux')
            echo -e "\n${gelb}➀ Installierte Kernel prĂŒfen:${reset}"
            eol_warning=0
            for k in "${installed[@]}"; do
                if printf "%s\n" "${eol_list[@]}" | grep -qx "$k"; then
                    echo -e " → ${rot}Kernel $k ist EOL${reset}"
                    eol_warning=1
                else
                    echo -e " → ${gruen}Kernel $k ist OK${reset}"
                fi
            done

            if [ "$eol_warning" -gt 0 ]; then
                echo -e "\n${rot}⚠  Mindestens ein installierter Kernel ist veraltet (EOL).${reset}"
            else
                echo -e "\n${gruen}✅ Alle installierten Kernel sind aktuell.${reset}"
            fi

            propose_lts

            echo -e "\n${gelb}➀ Systemaktualisierung lĂ€uft, STRG+C ist deaktiviert...${reset}"

            # FĂŒhrt eine vollstĂ€ndige Systemaktualisierung durch:
            # - Syy: Erzwingt das Neuladen aller Paketdatenbanken
            # - uu: FĂŒhrt zusĂ€tzlich auch Downgrades durch, wenn eine Ă€ltere Version im Repo liegt
            # → Sinnvoll bei Branch-Wechseln oder zur Behebung von Paketinkonsistenzen
            # Hinweis: FĂŒr normale Updates genĂŒgt in der Regel "sudo pacman -Syu"

            # FĂŒhrt eine vollstĂ€ndige Systemaktualisierung durch:
            # Fragt interaktiv, ob mit -Syu (Standard) oder -Syyuu aktualisiert werden soll
            read -rp "Standard-Synchronisation (-Syu) [J] oder vollstÀndig (-Syyuu) [n]? (Standard: J): " choice
            if [[ "$choice" =~ ^[Jj]$ ]]; then
                run_soft_logged sudo pacman --color=never -Syu
            else
                run_soft_logged sudo pacman --color=never -Syyuu
            fi

            # Entfernt alle bis auf die zwei zuletzt installierten Versionen jedes Pakets aus dem Cache
            # → Spart Speicherplatz, behĂ€lt aber zwei Versionen fĂŒr eventuelle Rollbacks
            if command -v paccache &>/dev/null; then
                sudo paccache -rk2
            else
                echo "Hinweis: paccache nicht gefunden."
            fi

            echo -e "\n${gelb}➀ Verwaiste Pakete:${reset}"
            orphans=$(sudo pacman -Qdtq || true)
            if [ -z "$orphans" ]; then
                echo "${gruen}Keine verwaisten Pakete gefunden.${reset}"
            else
                echo "$orphans"
            fi

            update_flatpak

            if update_grub && [ "$grub_diag" -eq 1 ]; then
                check_grub_health
            fi

            press_enter

            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        2)
            CURRENT_STEP_NAME="Punkt 2 - System ĂŒber AUR aktualisieren (yay)"
            log_start "$CURRENT_STEP_NAME"
            # AUR Systemaktualisierung (yay)
            echo -e "\n${gelb}➀ AUR Systemaktualisierung gestartet...${reset}"

            if ! command -v yay &>/dev/null; then
                echo -e "${rot}Fehler: yay ist nicht installiert!${reset}"
                echo -e " → Bitte zuerst mit: ${gruen}sudo pacman -S yay${reset}"
                press_enter
                break
            fi

            echo -e "\n${gelb}➀ Offizielle Repos synchronisieren...${reset}"
            sudo pacman -Syy

            echo -e "\n${gelb}➀ AUR und Repo-Pakete aktualisieren, STRG+C ist deaktiviert...${reset}"

            # FĂŒhrt eine vollstĂ€ndige Systemaktualisierung durch:
            # - Syy: Erzwingt das Neuladen aller Paketdatenbanken
            # - uu: FĂŒhrt zusĂ€tzlich auch Downgrades durch, wenn eine Ă€ltere Version im Repo oder in der AUR vorliegt
            # → Sinnvoll bei Branch-Wechseln oder zur Behebung von Paketinkonsistenzen
            # Hinweis: FĂŒr normale Updates genĂŒgt in der Regel "yay -Syu"

            # FĂŒhrt eine vollstĂ€ndige Systemaktualisierung durch:
            # Fragt interaktiv, ob mit -Syu (Standard) oder -Syyuu aktualisiert werden soll
            read -rp "Standard-Synchronisation (-Syu) [J] oder vollstÀndig (-Syyuu) [n]? (Standard: J): " choice
            if [[ "$choice" =~ ^[Jj]$ ]]; then
                run_soft_logged yay --color=never -Syu
            else
                run_soft_logged yay --color=never -Syyuu
            fi

            # Entfernt alle bis auf die zwei zuletzt installierten Versionen jedes Pakets aus dem Cache
            # → Spart Speicherplatz, behĂ€lt aber zwei Versionen fĂŒr eventuelle Rollbacks
            if command -v paccache &>/dev/null; then
                sudo paccache -rk2
            else
                echo "Hinweis: paccache nicht gefunden."
            fi

            echo -e "\n${gelb}➀ Verwaiste Pakete:${reset}"
            orphans=$(sudo pacman -Qdtq || true)
            if [ -z "$orphans" ]; then
                echo "${gruen}Keine verwaisten Pakete gefunden.${reset}"
            else
                echo "$orphans"
            fi

            update_flatpak

            if update_grub && [ "$grub_diag" -eq 1 ]; then
                check_grub_health
            fi

            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        3)
            CURRENT_STEP_NAME="Punkt 3 - Verwaiste Pakete entfernen"
            log_start "$CURRENT_STEP_NAME"
            # Verwaiste Pakete löschen
            mapfile -t orphans < <(pacman -Qdtq)
            if [ ${#orphans[@]} -gt 0 ]; then
                if [ "${LOGGING:-}" = "true" ]; then
                    {
                        echo "ORPHANS_BEFORE (${#orphans[@]}):"
                        printf '%s\n' "${orphans[@]}"
                    } >> "${LOG_FILE}"
                fi
                run_soft_logged sudo pacman --color=never -Rsn "${orphans[@]}"
            else
                echo "Keine verwaisten Pakete gefunden."
            fi
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        4)
            CURRENT_STEP_NAME="Punkt 4 - Paket-Caches vollstÀndig löschen"
            log_start "$CURRENT_STEP_NAME"
            # Alle Caches löschen
            echo -e "\n${gelb}➀ Alle Caches löschen (pacman + yay):${reset}"
            echo "(Mehrere RĂŒckfragen möglich – bewusst bestĂ€tigen!)"

            # AufrÀumaktion: temporÀre Download-Verzeichnisse löschen
            # Beispiel: Wenn die Meldung erscheint –
            # "Fehler: /var/cache/pacman/download-pZbyXs konnte nicht entfernt werden: Ist ein Verzeichnis"
            read -r -p "➀ TemporĂ€re download-* Verzeichnisse löschen? [j/N]: " confirm
            if [[ "$confirm" =~ ^[Jj]$ ]]; then
                echo "→ download-* Verzeichnisse aufrĂ€umen..."
                sudo find /var/cache/pacman/pkg -type d -name 'download-*' -exec rm -r {} +
            fi

           # Löscht alle zwischengespeicherten Pakete vollstÀndig (Cache vollstÀndig leeren)
           # → Achtung: Nach dem Löschen mĂŒssen alle Pakete bei Bedarf neu aus dem Internet geladen werden
           # yay -Scc: fĂŒr Systeme mit AUR-UnterstĂŒtzung (yay installiert)
           # pacman -Scc: Standard fĂŒr Systeme ohne yay
            if command -v yay &>/dev/null; then
                yay -Scc
            else
                sudo pacman -Scc
            fi

            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        5)
            CURRENT_STEP_NAME="Punkt 5 - Spiegelserver fĂŒr DE/FR/AT aktualisieren"
            log_start "$CURRENT_STEP_NAME"
            # Spiegelserver aus DE/FR/AT optimieren
            echo -e "\nSpiegelserver D/F/Ö aktualisieren:\n"
            sudo pacman-mirrors --country Germany,France,Austria
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        6)
            CURRENT_STEP_NAME="Punkt 6 - Zugriffsrechte im Home-Verzeichnis korrigieren"
            log_start "$CURRENT_STEP_NAME"
            # Zugriffsrechte aktualisieren
            echo -e "\nZugriffsrechte neu setzen:\n"

            echo "→ Besitzerrechte im Home-Verzeichnis setzen..."
            sudo chown -R "$USER:$USER" "$HOME"

            if [ "$zugriffsrechte" -gt 0 ]; then
                echo "→ Standardrechte setzen (Verzeichnisse 755, Dateien 644, Home 711 fĂŒr Apache-Zugriff)..."
                sudo find "$HOME" -type d -exec chmod 755 {} +
                sudo find "$HOME" -type f -exec chmod 644 {} +
                chmod 711 "$HOME"

                if [ -d "$HOME/.gnupg" ]; then
                    echo "→ Spezielle Rechte fĂŒr .gnupg anwenden..."
                    sudo find "$HOME/.gnupg" -type d -exec chmod 700 {} +
                    sudo find "$HOME/.gnupg" -type f -exec chmod 600 {} +
                fi

                if [ -d "$HOME/.ssh" ]; then
                    echo "→ Rechte fĂŒr .ssh setzen..."
                    sudo chmod 700 "$HOME/.ssh"
                    sudo find "$HOME/.ssh" -type f -name "id_*" ! -name "*.pub" -exec chmod 600 {} +
                    sudo find "$HOME/.ssh" -type f -name "*.pub" -exec chmod 644 {} +
                    [ -f "$HOME/.ssh/authorized_keys" ] && sudo chmod 600 "$HOME/.ssh/authorized_keys"
                    [ -f "$HOME/.ssh/config" ] && sudo chmod 600 "$HOME/.ssh/config"
                    [ -f "$HOME/.ssh/known_hosts" ] && sudo chmod 644 "$HOME/.ssh/known_hosts"
                    echo "Hinweis: Rechte fĂŒr .ssh angepasst."
                fi

                if [ -d "$HOME/.aws" ]; then
                    echo "→ Rechte fĂŒr .aws setzen..."
                    sudo chmod 700 "$HOME/.aws"
                    for awsfile in "$HOME/.aws/config" "$HOME/.aws/credentials"; do
                        if [ -f "$awsfile" ]; then
                            sudo chmod 600 "$awsfile"
                            echo "Hinweis: Rechte fĂŒr $awsfile auf 600 gesetzt."
                        fi
                    done
                fi

                echo "→ Rechte fĂŒr sensible Dateien (.env, .secrets etc.) setzen..."
                for file in "$HOME/.env" "$HOME/.vps-env" "$HOME/.secrets" "$HOME/.netrc" "$HOME/.pypirc" "$HOME/.git-credentials"; do
                    if [ -f "$file" ]; then
                        sudo chmod 600 "$file"
                        echo "Hinweis: Rechte fĂŒr $file auf 600 gesetzt."
                    fi
                done
            fi

            if [ "$html" -eq 1 ]; then
                echo "→ Rechte fĂŒr public_html setzen (Home 711 fĂŒr Apache-Zugriff)..."
                chmod 711 "$HOME"
                sudo chown -R http:http "$HOME/public_html"
                sudo find "$HOME/public_html" -type d -exec chmod 2775 {} +
                sudo find "$HOME/public_html" -type f -exec chmod 0664 {} +
            fi

            echo "→ Setze AusfĂŒhrbarkeit fĂŒr *.sh, *.desktop und *.AppImage..."
            sudo find "$HOME" -name "*.sh" -exec chmod 0744 {} +
            sudo find "$HOME" -name "*.desktop" -exec chmod 0744 {} +
            sudo find "$HOME" -name "*.AppImage" -exec chmod 0744 {} +

            echo -e "\n✅ Alle Berechtigungen wurden gesetzt."
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        7)
            CURRENT_STEP_NAME="Punkt 7 - Systeminformationen anzeigen"
            log_start "$CURRENT_STEP_NAME"
            # Systeminformationen anzeigen
            echo -e "\nSysteminformationen:\n"
            if command -v lsb_release &>/dev/null; then
               lsb_release -a
            else
               echo "lsb_release nicht gefunden."
            fi

            if command -v inxi &>/dev/null; then
                inxi -Fz
            else
                echo "inxi nicht gefunden."
            fi
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        8)
            CURRENT_STEP_NAME="Punkt 8 - Fehler/Kritisch seit letztem Boot (journalctl)"
            log_start "$CURRENT_STEP_NAME"

            echo -e "\n${gelb}➀ Fehler/Kritisch seit letztem Boot (journalctl -b -p 3 --no-pager):${reset}"
            if command -v journalctl >/dev/null 2>&1; then
                # Erst ohne sudo versuchen (reicht i. d. R.),
                # bei Fehler (z. B. wegen Rechten) fallback mit sudo.
                if ! journalctl -b -p 3 --no-pager; then
                    echo -e "\n${gelb}Hinweis:${reset} erneuter Versuch mit sudo
"
                    sudo journalctl -b -p 3 --no-pager || true
                fi
            else
                echo -e "${rot}journalctl nicht gefunden – System ohne systemd oder Tool fehlt.${reset}"
            fi

            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        9)
            CURRENT_STEP_NAME="Punkt 9 - Temperatur-Sensorwerte anzeigen"
            log_start "$CURRENT_STEP_NAME"
            # Temperatursensoren ausgeben
            echo -e "\nTemperatursensoren:\n"
            if command -v sensors &>/dev/null; then
                sensors
            else
                echo "sensors nicht gefunden."
            fi
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        10)
            CURRENT_STEP_NAME="Punkt 10 - NVMe S.M.A.R.T.-Status anzeigen"
            log_start "$CURRENT_STEP_NAME"
            echo -e "\nNVMe SSD S.M.A.R.T. LOG:\n"

            if ! command -v nvme >/dev/null 2>&1; then
                echo "${rot}nvme-cli ist nicht installiert. Bitte 'nvme-cli' nachinstallieren.${reset}"
            else
                nvmes=$(ls /dev/nvme[0-9] 2>/dev/null | grep -E '^/dev/nvme[0-9]$' || true) # nur Controller: /dev/nvme0, /dev/nvme1, ...

                # Jeder gefundene Controller wird einzeln mit nvme smart-log geprĂŒft.
                # Namespaces und Partitionen (z.B. /dev/nvme0n1, /dev/nvme0n1p1) werden bewusst ausgelassen,
                # um doppelte oder unĂŒbersichtliche Ausgaben zu vermeiden.

                if [ -z "$nvmes" ]; then
                    echo "${rot}Keine NVMe-SSD gefunden.${reset}"
                else
                    for dev in $nvmes; do
                        echo "${gruen}S.M.A.R.T.-Log fĂŒr $dev:${reset}"
                        if ! sudo nvme smart-log "$dev"; then
                            echo "${rot}Fehler: Kein Zugriff auf $dev oder Befehl nicht unterstĂŒtzt.${reset}"
                        fi
                        echo ""
                        echo "---------------------------------------------"
                    done
                fi
            fi

            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        11)
            CURRENT_STEP_NAME="Punkt 11 - USB S.M.A.R.T.-Status anzeigen"
            log_start "$CURRENT_STEP_NAME"

            if ! command -v smartctl >/dev/null 2>&1; then
                echo "${rot}smartmontools ist nicht installiert. Bitte 'smartmontools' nachinstallieren.${reset}"
            else
                echo "${blau}Suche nach USB-Laufwerken...${reset}"
                usb_devs=$(lsblk -d -o NAME,TRAN | awk '$2=="usb"{print $1}')

                if [ -z "$usb_devs" ]; then
                    echo "${rot}Keine USB-Laufwerke gefunden.${reset}"
                else
                    for dev in $usb_devs; do
                        echo "${blau}PrĂŒfe /dev/$dev ...${reset}"

                        # Versuchskette: normal → -d sat → -d scsi → -T permissive
                        # Hintergrund: Manche USB-Adapter leiten SMART nur mit bestimmten Treiber-Optionen durch.
                        # Mit -T permissive werden notfalls eingeschrÀnkte Infos angezeigt.

                        if ! sudo smartctl -a /dev/$dev; then
                            if ! sudo smartctl -a -d sat /dev/$dev; then
                                if ! sudo smartctl -a -d scsi /dev/$dev; then
                                    sudo smartctl -a -T permissive /dev/$dev
                                fi
                            fi
                        fi

                        echo "---------------------------------------------"
                    done
                fi
            fi

            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        12)
            CURRENT_STEP_NAME="Punkt 12 - Pacman-Datenbanksperre entfernen"
            log_start "$CURRENT_STEP_NAME"
            # Datenbanksperre löschen
            echo -e "\nDatenbanksperre löschen:\n"
            if [ -f /var/lib/pacman/db.lck ]; then
                sudo rm -f /var/lib/pacman/db.lck
            else
                echo "Keine Datenbanksperre gefunden."
            fi
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        13)
            CURRENT_STEP_NAME="Punkt 13 - fstrim auf SSDs ausfĂŒhren"
            log_start "$CURRENT_STEP_NAME"
            # fstrim ausfĂŒhren
            echo -e "\nfstrim auf SSDs:\n"
            if command -v fstrim &>/dev/null; then
                sudo fstrim -av
            else
                echo "${rot}fstrim ist nicht installiert.${reset}"
            fi
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        14)
            CURRENT_STEP_NAME="Punkt 14 - Speicherplatz anzeigen (ZurĂŒck mit Taste Q)"
            log_start "$CURRENT_STEP_NAME"
            # Speicherplatz anzeigen (df -h)
            echo -e "\n${gelb}➀ Speicherplatz anzeigen (df -h)...${reset}"
            df -h | less
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        15)
            CURRENT_STEP_NAME="Punkt 15 - Systemmonitor htop starten (ZurĂŒck F10)"
            log_start "$CURRENT_STEP_NAME"
            # htop starten
            echo -e "\n${gelb}➀ Starte htop...${reset}"
            if command -v htop &>/dev/null; then
                htop
            else
                echo -e "${rot}htop ist nicht installiert.${reset}"
            fi
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        16)
            CURRENT_STEP_NAME="Punkt 16 - Btrfs-DatenprĂŒfung (scrub) – kann dauern"
            log_start "$CURRENT_STEP_NAME"
            # Btrfs-DatenprĂŒfung (scrub)
            echo "${blau}Starte Btrfs scrub – kann einige Zeit dauern...${reset}"
            sudo btrfs scrub start -Bd /
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        17)
            CURRENT_STEP_NAME="Punkt 17 - Btrfs-PrĂŒfstatus anzeigen"
            log_start "$CURRENT_STEP_NAME"
            # Btrfs-PrĂŒfstatus anzeigen
            echo "${blau}Btrfs scrub Status:${reset}"
            sudo btrfs scrub status /
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;
        18)
            CURRENT_STEP_NAME="Punkt 18 - GRUB-Diagnose"
            log_start "$CURRENT_STEP_NAME"
            check_grub_health
            press_enter
            ec=$?
            log_end "$CURRENT_STEP_NAME" "$ec"
            unset CURRENT_STEP_NAME
            ;;

        0)
            echo "${gruen}Skript wird beendet.${reset}"
            exit 0
            ;;
        *)
            echo "${rot}UngĂŒltige Auswahl.${reset}"
            press_enter
            ;;
    esac
done

Beispiel: KDE Shortcut tweaksManjaro.desktop

[Desktop Entry]
Comment[de_DE]=
Comment=
Exec=konsole -e '~/bin/tweaksManjaro.sh'
GenericName[de_DE]=
GenericName=
Icon=update-none-symbolic
MimeType=
Name[de_DE]=tweaksManjaro
Name=tweaksManjaro
Path=
StartupNotify=true
Terminal=false
TerminalOptions=
Type=Application
X-DBUS-ServiceName=
X-DBUS-StartupType=
X-KDE-SubstituteUID=false
X-KDE-Username=
Back to top