Make fwupdmgr hint conditional

Only show fwupmgr hint if firmware updates are available
Also fold that and git-monitor hint in a single notification

PKGBUILD

@@ -3,7 +3,7 @@
 # Maintainer: Daniele Fucini <dfucini [at] gmail [dot] com>
 
 pkgname=update-notify
-pkgver=2.0
+pkgver=3.0.2
 pkgrel=1
 pkgdesc='Notify when updates are available'
 arch=('any')
@@ -15,7 +15,7 @@ makedepends=('git')
 optdepends=('git-monitor: to check git repos for updates')
 source=(git+${url}?signed#tag=${pkgver})
 validpgpkeys=('7E12BC1FF3B6EDB2CD8053EB981A2B2A3BBF5514')
-sha256sums=('907b2f1ad229096dc520a65e8e4319dba575a759d2e23248aff810e01d0c4a02')
+sha256sums=('3541f7b27a48316ba6cf7acb243cb50ae024ff139a39837ab78cb0ec9007efcd')
 
 package()
 {

update-notify

@@ -1,69 +1,127 @@
 #!/bin/bash
+set -u
 
-# Default threshold or user argument
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
 threshold=${1:-30}
+AUR_REPO="aur-local"
+# stock kernel package -> your custom build of it. Add or remove entries freely.
+declare -A KERNELS=(
+    [linux]="linux-custom"
+    [linux-lts]="linux-lts-custom"
+    [linux-zen]="linux-zen-custom"
+)
+state_dir="${XDG_STATE_HOME:-$HOME/.local/state}/update-notify"
 
-# Fetch checkupdates once to prevent multiple network/disk calls
+[[ $threshold =~ ^[0-9]+$ ]] || { echo "Threshold must be a number" >&2; exit 1; }
-mapfile -t arch_list < <(checkupdates 2>/dev/null)
+mkdir -p "$state_dir"
-arch_updates=${#arch_list[@]}
 
-# Count AUR updates safely
+# notify-send from cron/systemd needs the session bus address
-aur_updates=$(aur repo -u -d aur-local 2>/dev/null | wc -l)
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=/run/user/$(id -u)/bus}"
-updates=$((arch_updates + aur_updates))
 
-# Check kernel running environment
+# ---------------------------------------------------------------------------
-running_kernel=$(uname -r)
+# Helpers
-is_lts=0; [[ $running_kernel == *lts* ]] && is_lts=1
+# ---------------------------------------------------------------------------
 
-# Convert the array to a single string for quick regex matching
+# Send a notification only if its body changed since last time for this key.
-arch_str="${arch_list[*]}"
+notify_once() {
-
+    local key=$1 title=$2 body=$3
-# Check for custom package updates in the list
+    local file="$state_dir/$key"
-has_custom=0;     [[ $arch_str == *linux-custom* ]] && has_custom=1
+    if [[ -f $file && $(<"$file") == "$body" ]]; then
-has_custom_lts=0; [[ $arch_str == *linux-lts-custom* ]] && has_custom_lts=1
-
-# Define localized logic for kernel checking
-check_kernel_update() {
-    local pkg=$1
-    local item
-
-    # Precise array element matching (avoids false-positive substring matches)
-    for item in "${arch_list[@]}"; do
-        if [[ "$item" == "$pkg "* ]]; then
-            return 0 # Package found in the updates array, update is definitely available
-        fi
-    done
-
-    # Fallback to vercmp if running kernel doesn't match the sync repo
-    local repo_ver
-    repo_ver=$(pacman -Si "$pkg" 2>/dev/null | awk -F': ' '/Version/ {print $2}')
-
-    # Crucial Fix: vercmp returns > 0 ONLY if repo_ver is strictly newer than running_kernel
-    if [[ -n $repo_ver ]] && (( $(vercmp "$repo_ver" "$running_kernel") > 0 )); then
         return 0
     fi
+    printf '%s' "$body" > "$file"
+    notify-send "$title" "$body"
+}
+
+# Forget a key so the next occurrence notifies again.
+clear_state() {
+    rm -f "$state_dir/$1"
+}
+
+# If $1 has a pending update, print its new version and return 0.
+# checkupdates lines look like: "pkgname oldver -> newver"
+pending_version() {
+    local pkg=$1 item new
+    for item in "${arch_list[@]}"; do
+        if [[ $item == "$pkg "* ]]; then
+            read -r _ _ _ new <<< "$item"
+            printf '%s\n' "$new"
+            return 0
+        fi
+    done
     return 1
 }
 
-# Evaluate Kernel notifications based on environment
+# ---------------------------------------------------------------------------
-if (( is_lts == 0 && has_custom == 0 )); then
+# Gather updates
-    check_kernel_update "linux" && notify-send "Kernel update available" "Rebuild custom kernel"
+# ---------------------------------------------------------------------------
-elif (( is_lts == 1 && has_custom_lts == 0 )); then
+
-    check_kernel_update "linux-lts" && notify-send "LTS Kernel update available" "Rebuild custom kernel"
+# Fetch checkupdates once. Exit codes: 0 = updates, 2 = none, 1 = error.
+checkupdates_out=$(checkupdates 2>/dev/null)
+checkupdates_rc=$?
+if (( checkupdates_rc == 1 )); then
+    echo "checkupdates failed (network or sync problem?)" >&2
 fi
 
+arch_list=()
+if [[ -n $checkupdates_out ]]; then
+    mapfile -t arch_list <<< "$checkupdates_out"
+fi
+arch_updates=${#arch_list[@]}
 
-# Main updates notification threshold logic
+aur_updates=0
+if command -v aur >/dev/null 2>&1; then
+    aur_updates=$(aur repo -u -d "$AUR_REPO" 2>/dev/null | wc -l)
+fi
+updates=$((arch_updates + aur_updates))
+
+# ---------------------------------------------------------------------------
+# Kernel check: the stock kernel updated, but your custom build didn't
+# ---------------------------------------------------------------------------
+for stock_pkg in "${!KERNELS[@]}"; do
+    custom_pkg=${KERNELS[$stock_pkg]}
+
+    # Only relevant if the custom kernel is installed and has no pending update itself
+    if pacman -Q "$custom_pkg" >/dev/null 2>&1 && ! pending_version "$custom_pkg" >/dev/null; then
+        if stock_ver=$(pending_version "$stock_pkg"); then
+            notify_once "kernel-$stock_pkg" "Kernel update available: $stock_pkg" \
+                "Rebuild $custom_pkg ($stock_pkg $stock_ver)"
+            continue
+        fi
+    fi
+    clear_state "kernel-$stock_pkg"
+done
+
+# ---------------------------------------------------------------------------
+# General updates threshold
+# ---------------------------------------------------------------------------
 if (( updates >= threshold )); then
-    notify-send "Updates available" "Arch: $arch_updates, AUR: $aur_updates"
+    reminders=()
 
-    # Directly check command availability inline (no function needed)
+    # Always remind about git packages if git-monitor is installed
     if command -v git-monitor >/dev/null 2>&1; then
-        notify-send "Check git packages" "Use git-monitor for git packages updates"
+        reminders+=("git-monitor")
     fi
 
+    # Firmware: only mention it when updates actually exist.
+    # fwupdmgr get-updates exits 0 when updates are available, 2 when there are none.
+    # --no-metadata-check avoids prompting/refreshing; the fwupd-refresh timer keeps metadata fresh.
     if command -v fwupdmgr >/dev/null 2>&1; then
-        notify-send "Check firmware" "Use fwupdmgr to check for firmware updates"
+        timeout 30 fwupdmgr get-updates --no-metadata-check </dev/null >/dev/null 2>&1
+        if (( $? == 0 )); then
+            reminders+=("fwupdmgr (firmware updates available)")
+        fi
     fi
-fi
 
+    body="Arch: $arch_updates, AUR: $aur_updates"
+    if (( ${#reminders[@]} )); then
+        printf -v list '%s, ' "${reminders[@]}"
+        body+=$'\n'"Also check: ${list%, }"
+    fi
+
+    notify_once "updates" "Updates available" "$body"
+else
+    clear_state "updates"
+fi

update-notify.timer

@@ -3,7 +3,7 @@ Description=Run update-notify every 6 hours
 
 [Timer]
 OnBootSec=5min
-OnUnitActiveSec=12h
+OnUnitActiveSec=6h
 Persistent=true
 
 [Install]