Empty the default KERNELS map and make tests chroot-safe

Custom kernels are now set only in the config, so the defaults suit any system. The reboot check's modules folder can be overridden with UPDATE_NOTIFY_MODULES_DIR, so the tests no longer need an installed kernel.

.gitignore

@@ -0,0 +1 @@
+CLAUDE.md

PKGBUILD

@@ -2,36 +2,31 @@
 
 # Maintainer: Daniele Fucini <dfucini [at] gmail [dot] com>
 
-pkgname=update-notify-git
+pkgname=update-notify
-_pkgname=update-notify
+pkgver=3.12
-pkgdesc='Notify when updates are available'
-pkgver=0.0.1
 pkgrel=1
-url="https://github.com/Fuxino/${_pkgname}"
+pkgdesc='Notify when updates are available'
 arch=('any')
+url="https://git.shouldnt.work/fuxino/$pkgname"
 license=('GPL-3.0-or-later')
-makedepends=('git')
 depends=('pacman-contrib'
-         'aurutils')
+         'libnotify')
-source=(git+${url}.git?signed#branch=master)
+makedepends=('git')
+optdepends=('aurutils: to check AUR packages in the local repo for updates'
+            'fwupd: to check for firmware updates'
+            'git-monitor: to check git repos for updates')
+source=("git+$url?signed#tag=$pkgver")
 validpgpkeys=('7E12BC1FF3B6EDB2CD8053EB981A2B2A3BBF5514')
-sha256sums=('SKIP')
+sha256sums=('f8200d02a386475062c5e6895b6a19135e7523ca2e0961e0f9891e5f32e69356')
-
-pkgver() 
-{  
-    cd ${_pkgname}
-    git describe --long --tags | sed 's/\([^-]*-g\)/r\1/;s/-/./g'
-}
-
-prepare()
-{
-    git -C ${srcdir}/${_pkgname} clean -dfx
-}
 
 package()
 {
-    cd ${srcdir}/${_pkgname}
+    cd "$srcdir"/"$pkgname"
-    install -Dm755 ${_pkgname} ${pkgdir}/usr/bin/${_pkgname}
+    install -Dm755 "$pkgname" "$pkgdir"/usr/bin/"$pkgname"
-    install -Dm644 ${_pkgname}.service ${pkgdir}/usr/lib/systemd/user/${_pkgname}.service
+    install -Dm644 "$pkgname".service "$pkgdir"/usr/lib/systemd/user/"$pkgname".service
-    install -Dm644 ${_pkgname}.timer ${pkgdir}/usr/lib/systemd/user/${_pkgname}.timer
+    install -Dm644 "$pkgname"-quiet.service "$pkgdir"/usr/lib/systemd/user/"$pkgname"-quiet.service
+    install -Dm644 "$pkgname".timer "$pkgdir"/usr/lib/systemd/user/"$pkgname".timer
+    install -Dm644 "$pkgname".path "$pkgdir"/usr/lib/systemd/user/"$pkgname".path
+    install -Dm644 README.md "$pkgdir"/usr/share/doc/"$pkgname"/README.md
+    install -Dm644 config.example "$pkgdir"/usr/share/doc/"$pkgname"/config.example
 }

README.md

@@ -0,0 +1,115 @@
+# update-notify
+
+Desktop notifications for pending updates on Arch Linux.
+
+update-notify runs on a systemd user timer and checks:
+
+- **Repo updates**, using `checkupdates` from pacman-contrib.
+- **AUR updates** for packages in a local aurutils repository (`aur repo -u`).
+- **Custom kernel rebuilds**: when a stock kernel (e.g. `linux-lts`) has a newer version than your custom build of it (e.g. `linux-lts-custom`), for the kernels set in `KERNELS`.
+- **Maintenance**: `.pacnew`/`.pacsave` files to merge (`pacdiff -o`), and a reboot after the running kernel was upgraded.
+
+It sends one notification, and only when its content changes since the last one:
+
+- Update counts are shown once the total number of updates reaches a threshold (default 30). Reminders for `git-monitor` and pending firmware updates (`fwupdmgr`) are added when those tools are installed.
+- Kernel rebuild reminders are always shown, even below the threshold.
+- Maintenance reminders are added to every notification. On their own, they notify only when something new appears (a new file to merge, a new kernel to reboot into), so a `.pacnew` you keep isn't repeated.
+
+## Requirements
+
+- `pacman-contrib`
+- `libnotify` and a running notification daemon
+
+Optional:
+
+- `aurutils`: check AUR packages in the local repository
+- `fwupd`: check for firmware updates
+- `git-monitor`: remind to check git packages
+
+## Installation
+
+Build and install the package with the included PKGBUILD, which builds the signed release tag set in `pkgver`:
+
+```
+makepkg -si
+```
+
+Or, with aurutils, build it into a local repository with `aur build` and install it with pacman.
+
+Then enable the timer:
+
+```
+systemctl --user enable --now update-notify.timer
+```
+
+The timer runs 5 minutes after boot, then every 6 hours.
+
+### Refresh after building packages
+
+To run `update-notify --quiet` whenever a repository changes, add the repository files to watch to `update-notify.path`:
+
+```
+systemctl --user edit update-notify.path
+```
+
+```
+[Path]
+PathChanged=/home/aur-local/aur-local.db.tar.gz.sig
+PathChanged=/home/custom-pkgs/custom-pkgs.db.tar.gz.sig
+```
+
+Watch the `.db.tar.gz.sig` file for signed repositories, or `.db.tar.gz` for unsigned ones (`.db` is a symlink). Then enable it:
+
+```
+systemctl --user enable --now update-notify.path
+```
+
+## Usage
+
+```
+update-notify [-q|--quiet] [threshold]
+```
+
+`threshold` is the minimum number of updates (repo + AUR) before update counts are shown. It overrides the `THRESHOLD` setting below for that run's notification only; the pending file keeps the configured value.
+
+`--quiet` updates the pending file without notifying. Changes to a notification already shown are recorded, so the next timer run doesn't repeat them; a new notification is left for the timer. `update-notify.path` uses it (through `update-notify-quiet.service`), so building many packages doesn't notify after each one.
+
+## Configuration
+
+Settings are read from `$XDG_CONFIG_HOME/update-notify/config` (default `~/.config/update-notify/config`), a bash file that is sourced by the script. All settings are optional:
+
+- `THRESHOLD`: minimum number of updates before update counts are shown (default 30).
+- `AUR_REPO`: name of the local aurutils repository (default `aur-local`).
+- `KERNELS`: maps each stock kernel package to its custom build, e.g. `KERNELS=([linux-lts]=linux-lts-custom)`. Empty by default, which disables the kernel check. Kernels where either package isn't installed are skipped.
+- `PACNEW_CHECK`: set to `0` to disable the `.pacnew`/`.pacsave` reminder (default `1`).
+- `REBOOT_CHECK`: set to `0` to disable the reboot reminder (default `1`). A reboot is needed when the running kernel's `/usr/lib/modules/<version>/vmlinuz` is gone.
+
+A commented sample config is installed with the package. To start from it:
+
+```
+mkdir -p ~/.config/update-notify
+cp /usr/share/doc/update-notify/config.example ~/.config/update-notify/config
+```
+
+Kernel versions are compared without `pkgrel`, so a stock packaging-only update doesn't trigger a rebuild reminder. A custom build already in the local repository but not installed yet counts as up to date.
+
+The content of the last notification is stored in `$XDG_STATE_HOME/update-notify` (default `~/.local/state/update-notify`). Delete it to get the current notification again.
+
+## Status bars
+
+Each run also writes the pending updates to `$XDG_STATE_HOME/update-notify/pending`, whether or not the threshold is reached, for status bars such as xmobar to read:
+
+```
+threshold <THRESHOLD from the config, not the argument>
+repo <pkg> <newver>
+aur <pkg> <newver>
+kernel <custom-pkg> <stock-ver>
+pacnew <path>
+reboot <running kernel version>
+```
+
+The file reflects the last timer or `update-notify.path` run. To keep a bar current in between, e.g. right after an upgrade, drop entries whose installed version (`pacman -Q`) is no longer older than `newver`; for `kernel` lines, whose custom build has caught up with `stock-ver` (ignoring `pkgrel`); for `pacnew` lines, whose file is gone; for `reboot` lines, whose version is no longer `uname -r`. This only reads local data, so it's cheap to run often.
+
+## License
+
+GPL-3.0-or-later. See [LICENSE](LICENSE).

config.example

@@ -0,0 +1,24 @@
+# update-notify configuration, sourced as bash.
+# Copy to ~/.config/update-notify/config and uncomment what you want to change.
+# The values shown are the defaults.
+
+# Minimum number of updates (repo + AUR) before update counts are shown.
+# The command-line argument takes precedence.
+#THRESHOLD=30
+
+# Name of the local aurutils repository.
+#AUR_REPO="aur-local"
+
+# Stock kernel package -> your custom build of it, to be reminded to rebuild
+# it. Empty by default (no kernel check); kernels where either package isn't
+# installed are skipped. Example:
+#KERNELS=(
+#    [linux]="linux-custom"
+#    [linux-lts]="linux-lts-custom"
+#)
+
+# Remind about .pacnew/.pacsave files to merge with pacdiff (0 to disable).
+#PACNEW_CHECK=1
+
+# Remind to reboot after the running kernel was upgraded (0 to disable).
+#REBOOT_CHECK=1

tests/stubs/aur

@@ -0,0 +1,8 @@
+#!/bin/bash
+# "aur repo -u -d <repo>": prints $STUB_DATA/aur, exits $AUR_RC (default 0).
+printf '%s %s\n' "${0##*/}" "$*" >> "$STUB_DATA/calls"
+[[ ${1:-} == repo ]] || exit 1
+if [[ -s $STUB_DATA/aur ]]; then
+    printf '%s\n' "$(<"$STUB_DATA/aur")"
+fi
+exit "${AUR_RC:-0}"

tests/stubs/checkupdates

@@ -0,0 +1,8 @@
+#!/bin/bash
+# Prints $STUB_DATA/checkupdates; exits $CHECKUPDATES_RC, else 0 with updates and 2 without, like the real one.
+printf '%s %s\n' "${0##*/}" "$*" >> "$STUB_DATA/calls"
+if [[ -s $STUB_DATA/checkupdates ]]; then
+    printf '%s\n' "$(<"$STUB_DATA/checkupdates")"
+    exit "${CHECKUPDATES_RC:-0}"
+fi
+exit "${CHECKUPDATES_RC:-2}"

tests/stubs/fwupdmgr

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Exits $FWUPD_RC: 0 = firmware updates available, 2 (default) = none.
+printf '%s %s\n' "${0##*/}" "$*" >> "$STUB_DATA/calls"
+exit "${FWUPD_RC:-2}"

tests/stubs/git-monitor

@@ -0,0 +1,3 @@
+#!/bin/bash
+# Only needs to exist: the script checks for it with command -v.
+exit 0

tests/stubs/notify-send

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Appends the title, the body and a "--" line to $STUB_DATA/notify; exits $NOTIFY_RC (default 0).
+printf '%s\n' "$1" "$2" -- >> "$STUB_DATA/notify"
+exit "${NOTIFY_RC:-0}"

tests/stubs/pacdiff

@@ -0,0 +1,8 @@
+#!/bin/bash
+# "pacdiff -o": prints $STUB_DATA/pacdiff.
+printf '%s %s\n' "${0##*/}" "$*" >> "$STUB_DATA/calls"
+[[ ${1:-} == -o ]] || exit 1
+if [[ -s $STUB_DATA/pacdiff ]]; then
+    printf '%s\n' "$(<"$STUB_DATA/pacdiff")"
+fi
+exit 0

tests/stubs/pacman

@@ -0,0 +1,13 @@
+#!/bin/bash
+# "pacman -Q <pkg>": looks the package up in $STUB_DATA/installed ("name version" lines).
+[[ ${1:-} == -Q && $# == 2 ]] || { echo "pacman stub: unsupported arguments: $*" >&2; exit 1; }
+if [[ -f $STUB_DATA/installed ]]; then
+    while read -r name ver; do
+        if [[ $name == "$2" ]]; then
+            printf '%s %s\n' "$name" "$ver"
+            exit 0
+        fi
+    done < "$STUB_DATA/installed"
+fi
+printf "error: package '%s' was not found\n" "$2" >&2
+exit 1

tests/stubs/uname

@@ -0,0 +1,3 @@
+#!/bin/bash
+# "uname -r": prints $STUB_KERNEL.
+printf '%s\n' "$STUB_KERNEL"

tests/update-notify.bats

@@ -0,0 +1,410 @@
+#!/usr/bin/env bats
+# Black-box tests: the script runs with the stubs in tests/stubs and temp config/state folders.
+
+bats_require_minimum_version 1.5.0
+bats_load_library bats-support
+bats_load_library bats-assert
+
+SCRIPT=$BATS_TEST_DIRNAME/../update-notify
+
+setup() {
+    export STUB_DATA=$BATS_TEST_TMPDIR/data
+    export XDG_CONFIG_HOME=$BATS_TEST_TMPDIR/config
+    export XDG_STATE_HOME=$BATS_TEST_TMPDIR/state
+    # The running kernel has its vmlinuz, so the reboot check stays quiet unless a test changes STUB_KERNEL
+    export STUB_KERNEL=6.1.1-test
+    export UPDATE_NOTIFY_MODULES_DIR=$BATS_TEST_TMPDIR/modules
+    STATE=$XDG_STATE_HOME/update-notify
+    BIN=$BATS_TEST_TMPDIR/bin
+    mkdir -p "$STUB_DATA" "$XDG_CONFIG_HOME/update-notify" "$BIN" "$UPDATE_NOTIFY_MODULES_DIR/$STUB_KERNEL"
+    touch "$UPDATE_NOTIFY_MODULES_DIR/$STUB_KERNEL/vmlinuz"
+    # PATH holds only the stubs and the real tools the script needs, so a removed stub is a missing command
+    local tool
+    for tool in mkdir mv rm id timeout vercmp; do
+        ln -s "$(command -v "$tool")" "$BIN/$tool"
+    done
+    for tool in checkupdates aur pacman pacdiff uname notify-send; do
+        enable_stub "$tool"
+    done
+}
+
+enable_stub() { ln -s "$BATS_TEST_DIRNAME/stubs/$1" "$BIN/$1"; }
+disable_stub() { rm "$BIN/$1"; }
+config() { printf '%s\n' "$@" >> "$XDG_CONFIG_HOME/update-notify/config"; }
+repo_updates() { printf '%s\n' "$@" > "$STUB_DATA/checkupdates"; }
+aur_updates() { printf '%s\n' "$@" > "$STUB_DATA/aur"; }
+installed() { printf '%s\n' "$@" > "$STUB_DATA/installed"; }
+pacnew_files() { printf '%s\n' "$@" > "$STUB_DATA/pacdiff"; }
+custom_linux() { config "KERNELS=([linux]=linux-custom)"; }
+
+# Runs the script; notifications and stub calls are logged from this run only
+run_script() {
+    rm -f "$STUB_DATA/notify" "$STUB_DATA/calls"
+    run /usr/bin/env PATH="$BIN" "$SCRIPT" "$@"
+}
+
+# Args: title, then body lines
+assert_notification() {
+    local actual expected
+    actual=$(<"$STUB_DATA/notify") || fail "no notification sent"
+    printf -v expected '%s\n' "$@" --
+    assert_equal "$actual" "${expected%$'\n'}"
+}
+
+assert_no_notification() {
+    [[ ! -e $STUB_DATA/notify ]] || fail "unexpected notification: $(<"$STUB_DATA/notify")"
+}
+
+assert_pending() {
+    local expected
+    printf -v expected '%s\n' "$@"
+    assert_equal "$(<"$STATE/pending")" "${expected%$'\n'}"
+}
+
+assert_called() {
+    grep -qxF -- "$1" "$STUB_DATA/calls" || fail "not called: $1"
+}
+
+# --- Threshold and arguments ---
+
+@test "no updates: no notification, pending file has only the threshold" {
+    run_script
+    assert_success
+    assert_no_notification
+    assert_pending "threshold 30"
+}
+
+@test "below the threshold: no notification, updates listed in the pending file" {
+    repo_updates "foo 1-1 -> 2-1"
+    aur_updates "bar 1-1 -> 1.1-1"
+    run_script
+    assert_success
+    assert_no_notification
+    assert_pending "threshold 30" "repo foo 2-1" "aur bar 1.1-1"
+}
+
+@test "threshold reached: notifies the counts" {
+    config THRESHOLD=2
+    repo_updates "foo 1-1 -> 2-1"
+    aur_updates "bar 1-1 -> 1.1-1"
+    run_script
+    assert_success
+    assert_notification "Updates available" "Arch: 1, AUR: 1"
+}
+
+@test "threshold argument overrides the config, pending file keeps the config value" {
+    config THRESHOLD=5
+    repo_updates "foo 1-1 -> 2-1" "baz 1-1 -> 2-1"
+    run_script 2
+    assert_success
+    assert_notification "Updates available" "Arch: 2, AUR: 0"
+    assert_pending "threshold 5" "repo foo 2-1" "repo baz 2-1"
+}
+
+@test "threshold with a leading zero is read as decimal" {
+    repo_updates "a 1 -> 2" "b 1 -> 2" "c 1 -> 2" "d 1 -> 2" "e 1 -> 2" "f 1 -> 2" "g 1 -> 2" "h 1 -> 2" "i 1 -> 2"
+    run_script 010  # octal would be 8
+    assert_success
+    assert_no_notification
+}
+
+@test "non-numeric threshold argument fails before touching the state" {
+    run_script abc
+    assert_failure 1
+    assert_output "Threshold must be a number"
+    [[ ! -e $STATE ]]
+}
+
+@test "non-numeric threshold in the config fails" {
+    config THRESHOLD=many
+    run_script
+    assert_failure 1
+    assert_output "Threshold must be a number"
+}
+
+# --- Gathering updates ---
+
+@test "checkupdates failure exits without touching the state" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    run_script
+    assert_notification "Updates available" "Arch: 1, AUR: 0"
+    cp -r "$STATE" "$BATS_TEST_TMPDIR/before"
+
+    repo_updates "foo 1-1 -> 2-1" "baz 1-1 -> 2-1"
+    CHECKUPDATES_RC=1 run_script
+    assert_failure 1
+    assert_output --partial "checkupdates failed"
+    assert_no_notification
+    diff -r "$BATS_TEST_TMPDIR/before" "$STATE"
+}
+
+@test "aur repo -u failure warns and counts no AUR updates" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    aur_updates "bar 1-1 -> 1.1-1"
+    AUR_RC=1 run_script
+    assert_success
+    assert_output --partial "aur repo -u failed"
+    assert_notification "Updates available" "Arch: 1, AUR: 0"
+    assert_pending "threshold 1" "repo foo 2-1"
+}
+
+@test "aur missing: AUR updates count 0 without a warning" {
+    disable_stub aur
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    run_script
+    assert_success
+    assert_output ""
+    assert_notification "Updates available" "Arch: 1, AUR: 0"
+}
+
+@test "aur is queried for the configured repo" {
+    config AUR_REPO=myrepo
+    run_script
+    assert_success
+    assert_called "aur repo -u -d myrepo"
+}
+
+# --- Kernel check ---
+
+@test "no kernel check by default" {
+    installed "linux 6.1.1-1" "linux-custom 6.1.1-1"
+    repo_updates "linux 6.1.1-1 -> 6.1.2-1"
+    run_script
+    assert_success
+    assert_no_notification
+    assert_pending "threshold 30" "repo linux 6.1.2-1"
+}
+
+@test "stock kernel update notifies the rebuild below the threshold" {
+    custom_linux
+    installed "linux 6.1.1-1" "linux-custom 6.1.1-1"
+    repo_updates "linux 6.1.1-1 -> 6.1.2-1"
+    run_script
+    assert_success
+    assert_notification "Kernel update available" "Rebuild linux-custom (linux 6.1.2-1)"
+    assert_pending "threshold 30" "repo linux 6.1.2-1" "kernel linux-custom 6.1.2-1"
+}
+
+@test "kernel rebuild joins the counts over the threshold" {
+    config THRESHOLD=1
+    custom_linux
+    installed "linux 6.1.2-1" "linux-custom 6.1.1-1"
+    run_script 0
+    assert_success
+    assert_notification "Updates available" "Arch: 0, AUR: 0" "Rebuild linux-custom (linux 6.1.2-1)"
+}
+
+@test "kernel check ignores pkgrel" {
+    custom_linux
+    installed "linux 6.1.1-1" "linux-custom 6.1.1-1"
+    repo_updates "linux 6.1.1-1 -> 6.1.1-2"
+    run_script
+    assert_success
+    assert_no_notification
+}
+
+@test "custom kernel already built into the repo isn't flagged" {
+    custom_linux
+    installed "linux 6.1.1-1" "linux-custom 6.1.1-1"
+    repo_updates "linux 6.1.1-1 -> 6.1.2-1" "linux-custom 6.1.1-1 -> 6.1.2-1"
+    run_script
+    assert_success
+    assert_no_notification
+}
+
+@test "kernels without a custom build installed are skipped" {
+    custom_linux
+    installed "linux 6.1.1-1"
+    repo_updates "linux 6.1.1-1 -> 6.1.2-1"
+    run_script
+    assert_success
+    assert_no_notification
+}
+
+@test "custom kernel map comes from the config" {
+    config "KERNELS=([linux-hardened]=linux-hardened-mine)"
+    installed "linux-hardened 6.1.2-1" "linux-hardened-mine 6.1.1-1"
+    run_script
+    assert_success
+    assert_notification "Kernel update available" "Rebuild linux-hardened-mine (linux-hardened 6.1.2-1)"
+}
+
+# --- Notification state ---
+
+@test "same updates don't notify again, a change does" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    run_script
+    assert_notification "Updates available" "Arch: 1, AUR: 0"
+
+    run_script
+    assert_success
+    assert_no_notification
+
+    repo_updates "foo 1-1 -> 2-1" "baz 1-1 -> 2-1"
+    run_script
+    assert_notification "Updates available" "Arch: 2, AUR: 0"
+}
+
+@test "updates gone: the next ones notify again" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    run_script
+    rm "$STUB_DATA/checkupdates"
+    run_script
+    assert_no_notification
+    [[ ! -e $STATE/updates ]]
+
+    repo_updates "foo 1-1 -> 2-1"
+    run_script
+    assert_notification "Updates available" "Arch: 1, AUR: 0"
+}
+
+@test "failed notify-send isn't remembered, the next run retries" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    pacnew_files /etc/a.pacnew
+    NOTIFY_RC=1 run_script
+    [[ ! -e $STATE/updates && ! -e $STATE/maintenance ]]
+
+    run_script
+    assert_notification "Updates available" "Arch: 1, AUR: 0" "Config files to merge with pacdiff: 1"
+}
+
+# --- Quiet runs (path unit) ---
+
+@test "--quiet writes the pending file but leaves a new notification to the timer" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    run_script --quiet
+    assert_success
+    assert_no_notification
+    assert_pending "threshold 1" "repo foo 2-1"
+    [[ ! -e $STATE/updates ]]
+
+    run_script
+    assert_notification "Updates available" "Arch: 1, AUR: 0"
+}
+
+@test "--quiet tracks changes to a shown notification, so the timer doesn't repeat them" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    run_script
+    repo_updates "foo 1-1 -> 2-1" "baz 1-1 -> 2-1"
+    run_script -q
+    assert_no_notification
+
+    run_script
+    assert_no_notification
+}
+
+@test "--quiet leaves new maintenance items to the timer" {
+    pacnew_files /etc/a.pacnew
+    run_script --quiet
+    assert_no_notification
+    [[ ! -e $STATE/maintenance ]]
+
+    run_script
+    assert_notification "System maintenance" "Config files to merge with pacdiff: 1"
+}
+
+@test "--quiet takes a threshold argument after it" {
+    repo_updates "foo 1-1 -> 2-1"
+    run_script --quiet 1
+    assert_success
+    assert_no_notification
+    assert_pending "threshold 30" "repo foo 2-1"
+}
+
+# --- Maintenance reminders ---
+
+@test "pacnew files notify alone only when new" {
+    pacnew_files /etc/a.pacnew /etc/b.pacsave
+    run_script
+    assert_success
+    assert_notification "System maintenance" "Config files to merge with pacdiff: 2"
+    assert_pending "threshold 30" "pacnew /etc/a.pacnew" "pacnew /etc/b.pacsave"
+
+    run_script
+    assert_no_notification
+
+    pacnew_files /etc/a.pacnew /etc/b.pacsave /etc/c.pacnew
+    run_script
+    assert_notification "System maintenance" "Config files to merge with pacdiff: 3"
+
+    rm "$STUB_DATA/pacdiff"
+    run_script
+    assert_no_notification
+    [[ ! -e $STATE/maintenance ]]
+}
+
+@test "maintenance lines join every update notification" {
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    pacnew_files /etc/a.pacnew
+    run_script
+    assert_notification "Updates available" "Arch: 1, AUR: 0" "Config files to merge with pacdiff: 1"
+
+    repo_updates "foo 1-1 -> 2-1" "baz 1-1 -> 2-1"
+    run_script
+    assert_notification "Updates available" "Arch: 2, AUR: 0" "Config files to merge with pacdiff: 1"
+}
+
+@test "reboot reminder when the running kernel's vmlinuz is gone" {
+    STUB_KERNEL=0.0.0-gone run_script
+    assert_success
+    assert_notification "System maintenance" "Reboot to load the new kernel (running 0.0.0-gone)"
+    assert_pending "threshold 30" "reboot 0.0.0-gone"
+}
+
+@test "REBOOT_CHECK=0 disables the reboot reminder" {
+    config REBOOT_CHECK=0
+    STUB_KERNEL=0.0.0-gone run_script
+    assert_success
+    assert_no_notification
+}
+
+@test "PACNEW_CHECK=0 skips pacdiff" {
+    config PACNEW_CHECK=0
+    pacnew_files /etc/a.pacnew
+    run_script
+    assert_success
+    assert_no_notification
+    run ! grep -q '^pacdiff' "$STUB_DATA/calls"
+}
+
+# --- Reminders over the threshold ---
+
+@test "git-monitor and firmware reminders over the threshold" {
+    enable_stub git-monitor
+    enable_stub fwupdmgr
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    FWUPD_RC=0 run_script
+    assert_success
+    assert_notification "Updates available" "Arch: 1, AUR: 0" \
+        "Also check: git-monitor, fwupdmgr (firmware updates available)"
+    assert_called "fwupdmgr get-updates --no-metadata-check"
+}
+
+@test "no firmware reminder without firmware updates" {
+    enable_stub git-monitor
+    enable_stub fwupdmgr
+    config THRESHOLD=1
+    repo_updates "foo 1-1 -> 2-1"
+    run_script
+    assert_notification "Updates available" "Arch: 1, AUR: 0" "Also check: git-monitor"
+}
+
+@test "no reminders below the threshold" {
+    enable_stub git-monitor
+    enable_stub fwupdmgr
+    custom_linux
+    installed "linux 6.1.2-1" "linux-custom 6.1.1-1"
+    run_script
+    assert_notification "Kernel update available" "Rebuild linux-custom (linux 6.1.2-1)"
+    run ! grep -q '^fwupdmgr' "$STUB_DATA/calls"
+}

update-notify

@@ -1,21 +1,264 @@
 #!/bin/bash
+set -u
 
-if [ "$#" -eq 1 ]; then
+# ---------------------------------------------------------------------------
-    threshold=$1
+# Config: defaults, overridden by the config file, then by the argument
+# ---------------------------------------------------------------------------
+THRESHOLD=30
+AUR_REPO="aur-local"
+# stock kernel package -> your custom build of it; none by default.
+# Declared here so a [stock]=custom list in the config stays associative.
+declare -A KERNELS=()
+PACNEW_CHECK=1  # remind about .pacnew/.pacsave files (0 to disable)
+REBOOT_CHECK=1  # remind to reboot after a kernel upgrade (0 to disable)
+config_file="${XDG_CONFIG_HOME:-$HOME/.config}/update-notify/config"
+state_dir="${XDG_STATE_HOME:-$HOME/.local/state}/update-notify"
+
+if [[ -r $config_file ]]; then
+    # shellcheck source=/dev/null
+    source "$config_file"
+fi
+quiet=0  # refresh the pending file without notifying (path unit)
+if [[ ${1:-} == -q || ${1:-} == --quiet ]]; then
+    quiet=1
+    shift
+fi
+config_threshold=$THRESHOLD  # written to the pending file, so a one-off argument doesn't change status bars
+THRESHOLD=${1:-$THRESHOLD}
+
+for t in "$config_threshold" "$THRESHOLD"; do
+    [[ $t =~ ^[0-9]+$ ]] || { echo "Threshold must be a number" >&2; exit 1; }
+done
+# force base 10, so e.g. "08" isn't read as octal
+config_threshold=$((10#$config_threshold))
+THRESHOLD=$((10#$THRESHOLD))
+mkdir -p "$state_dir"
+
+# notify-send from cron/systemd needs the session bus address
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=/run/user/$(id -u)/bus}"
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+# 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
+}
+
+# Newest known version of $1: the pending version if an update is queued,
+# otherwise the installed version. Returns 1 if the package isn't installed.
+latest_version() {
+    local pkg=$1 ver
+    if ver=$(pending_version "$pkg"); then
+        printf '%s\n' "$ver"
+    elif ver=$(pacman -Q "$pkg" 2>/dev/null); then
+        printf '%s\n' "${ver#* }"
     else
-    threshold=30
+        return 1
+    fi
+}
+
+# ---------------------------------------------------------------------------
+# Gather updates
+# ---------------------------------------------------------------------------
+
+# Fetch checkupdates once. Exit codes: 0 = updates, 2 = none, 1 = error.
+checkupdates_out=$(checkupdates 2>/dev/null)
+checkupdates_rc=$?
+if (( checkupdates_rc == 1 )); then
+    # Bail out without touching the state, so the next good run doesn't re-notify
+    echo "checkupdates failed (network or sync problem?)" >&2
+    exit 1
 fi
 
-arch_updates=$(checkupdates | wc -l)
+arch_list=()
-aur_updates=$(aur repo -u -d aur-local | wc -l)
+if [[ -n $checkupdates_out ]]; then
-kernel_update=$(checkupdates | grep linux | wc -l)
+    mapfile -t arch_list <<< "$checkupdates_out"
+fi
+arch_updates=${#arch_list[@]}
 
-updates=$(($arch_updates + $aur_updates))
+aur_list=()
+if command -v aur >/dev/null 2>&1; then
+    if aur_out=$(aur repo -u -d "$AUR_REPO"); then
+        [[ -n $aur_out ]] && mapfile -t aur_list <<< "$aur_out"
+    else
+        echo "aur repo -u failed, AUR updates not counted" >&2
+    fi
+fi
+aur_updates=${#aur_list[@]}
+updates=$((arch_updates + aur_updates))
 
-if [ "$kernel_update" -ge 1 ]; then
+# ---------------------------------------------------------------------------
-    notify-send "Kernel update available" "Rebuild custom kernel to update"
+# Kernel check: the stock kernel updated, but your custom build didn't
+# ---------------------------------------------------------------------------
+kernel_lines=()
+kernel_pending=()
+for stock_pkg in "${!KERNELS[@]}"; do
+    custom_pkg=${KERNELS[$stock_pkg]}
+
+    # Skip kernels where either package isn't installed
+    if ! stock_ver=$(latest_version "$stock_pkg") || ! custom_ver=$(latest_version "$custom_pkg"); then
+        continue
     fi
 
-if [ "$updates" -ge "$threshold" ]; then
+    # Flag the kernel while the stock one is newer than the newest custom build
-    notify-send "Updates available" "Arch: $arch_updates, AUR: $aur_updates"
+    # (installed, or already built into your repo but not yet installed).
+    # pkgrel is ignored: a stock packaging-only bump doesn't need a rebuild.
+    if (( $(vercmp "${stock_ver%-*}" "${custom_ver%-*}") > 0 )); then
+        kernel_lines+=("Rebuild $custom_pkg ($stock_pkg $stock_ver)")
+        kernel_pending+=("$custom_pkg $stock_ver")
+    fi
+done
+
+# ---------------------------------------------------------------------------
+# Maintenance: config files to merge, reboot after a kernel upgrade.
+# maint_items are tracked in the state and the pending file, maint_lines are shown.
+# ---------------------------------------------------------------------------
+maint_items=()
+maint_lines=()
+if [[ $PACNEW_CHECK != 0 ]]; then
+    mapfile -t pacnew_files < <(pacdiff -o 2>/dev/null)
+    if (( ${#pacnew_files[@]} )); then
+        maint_items+=("${pacnew_files[@]/#/pacnew }")
+        maint_lines+=("Config files to merge with pacdiff: ${#pacnew_files[@]}")
+    fi
+fi
+running_kernel=$(uname -r)
+modules_dir=${UPDATE_NOTIFY_MODULES_DIR:-/usr/lib/modules}  # override for tests (build chroots have no kernel)
+# vmlinuz belongs to the kernel package, while DKMS files can keep the folder around
+if [[ $REBOOT_CHECK != 0 && ! -e $modules_dir/$running_kernel/vmlinuz ]]; then
+    maint_items+=("reboot $running_kernel")
+    maint_lines+=("Reboot to load the new kernel (running $running_kernel)")
+fi
+
+# ---------------------------------------------------------------------------
+# Pending list for status bars, one "<source> <pkg> <newver>" per line
+# ---------------------------------------------------------------------------
+{
+    printf 'threshold %s\n' "$config_threshold"
+    for item in "${arch_list[@]}"; do
+        read -r pkg _ _ new <<< "$item"
+        printf 'repo %s %s\n' "$pkg" "$new"
+    done
+    for item in "${aur_list[@]}"; do
+        read -r pkg _ _ new <<< "$item"
+        printf 'aur %s %s\n' "$pkg" "$new"
+    done
+    for item in "${kernel_pending[@]}"; do
+        printf 'kernel %s\n' "$item"
+    done
+    for item in "${maint_items[@]}"; do
+        printf '%s\n' "$item"
+    done
+} > "$state_dir/pending.tmp" && mv "$state_dir/pending.tmp" "$state_dir/pending"  # readers never see a partial file
+
+# ---------------------------------------------------------------------------
+# Build a single notification
+#   - kernel rebuild lines are always included
+#   - update counts and reminders only when the threshold is reached
+# ---------------------------------------------------------------------------
+over_threshold=0
+(( updates >= THRESHOLD )) && over_threshold=1
+
+parts=()
+if (( over_threshold )); then
+    parts+=("Arch: $arch_updates, AUR: $aur_updates")
+fi
+parts+=("${kernel_lines[@]}")
+
+if (( over_threshold )); then
+    reminders=()
+
+    # Always remind about git packages if git-monitor is installed
+    if command -v git-monitor >/dev/null 2>&1; then
+        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
+        if timeout 30 fwupdmgr get-updates --no-metadata-check </dev/null >/dev/null 2>&1; then
+            reminders+=("fwupdmgr (firmware updates available)")
+        fi
+    fi
+
+    if (( ${#reminders[@]} )); then
+        printf -v list '%s, ' "${reminders[@]}"
+        parts+=("Also check: ${list%, }")
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# Notify when the update part changed since the last notification (maintenance
+# lines included), or for maintenance alone when it has items not shown before
+# ---------------------------------------------------------------------------
+main_file="$state_dir/updates"
+main_body=""
+main_changed=0
+if (( ${#parts[@]} )); then
+    printf -v main_body '%s\n' "${parts[@]}"
+    main_body=${main_body%$'\n'}
+    [[ -f $main_file && $(<"$main_file") == "$main_body" ]] || main_changed=1
+else
+    rm -f "$main_file"  # so the next occurrence notifies again
+fi
+
+maint_file="$state_dir/maintenance"
+declare -A maint_seen=()
+if [[ -f $maint_file ]]; then
+    while IFS= read -r item; do
+        maint_seen["$item"]=1
+    done < "$maint_file"
+fi
+maint_new=0
+maint_kept=()  # current items already shown
+for item in "${maint_items[@]}"; do
+    if [[ -n ${maint_seen["$item"]:-} ]]; then
+        maint_kept+=("$item")
+    else
+        maint_new=1
+    fi
+done
+
+lines=()
+if (( main_changed )); then
+    lines=("${parts[@]}" "${maint_lines[@]}")
+    title="Updates available"
+    (( over_threshold )) || title="Kernel update available"
+elif (( maint_new )); then
+    lines=("${maint_lines[@]}")
+    title="System maintenance"
+fi
+
+shown=0
+if (( ${#lines[@]} )); then
+    printf -v body '%s\n' "${lines[@]}"
+    if (( quiet )); then
+        # Track changes to a shown notification, so the timer doesn't re-notify them;
+        # leave a new one for the timer to show
+        (( main_changed )) && [[ -f $main_file ]] && printf '%s' "$main_body" > "$main_file"
+    elif notify-send "$title" "${body%$'\n'}"; then
+        shown=1
+        [[ -n $main_body ]] && printf '%s' "$main_body" > "$main_file"
+    fi
+fi
+
+# Remember the maintenance items shown: drop resolved ones, keep new ones for the next notification
+maint_save=("${maint_kept[@]}")
+(( shown )) && maint_save=("${maint_items[@]}")
+if (( ${#maint_save[@]} )); then
+    printf '%s\n' "${maint_save[@]}" > "$maint_file"
+else
+    rm -f "$maint_file"
 fi

update-notify-quiet.service

@@ -0,0 +1,6 @@
+[Unit]
+Description=Refresh the update-notify pending file without notifying
+
+[Service]
+ExecStart=/usr/bin/update-notify --quiet
+Type=oneshot

update-notify.path

@@ -0,0 +1,10 @@
+[Unit]
+Description=Run update-notify when a local repository changes
+
+# Add the repository files to watch with: systemctl --user edit update-notify.path
+# e.g. PathChanged=/home/aur-local/aur-local.db.tar.gz.sig
+[Path]
+Unit=update-notify-quiet.service
+
+[Install]
+WantedBy=default.target

update-notify.service

@@ -2,6 +2,5 @@
 Description=Notify if updates are available
 
 [Service]
-ExecStart=/usr/bin/update-notify 30
+ExecStart=/usr/bin/update-notify
-Type=simple
+Type=oneshot
-Restart=no

update-notify.timer

@@ -4,7 +4,6 @@ Description=Run update-notify every 6 hours
 [Timer]
 OnBootSec=5min
 OnUnitActiveSec=6h
-Persistent=true
 
 [Install]
 WantedBy=timers.target