Script for checking for AUR updates

[haug1]

Who is this for

You are using Arch Linux and waybar. You have multiple display setup. Your waybar has a module which checks for system updates. (Though with some minor tinkering it may be applicable for other package managers as well, I'm not sure?)

Why am I posting this

I've been annoyed enough with this to make this script, so maybe I can help someone else. Also, I'm not sure how to properly present it/make it available, so I'm just putting it out there any way I can, and maybe someone will point me to a better solution!

Summary of the functionality

It will call checkupdates and yay -Qua to list all available updates. This response will be persistently stored with sqlite. It will output the number of available updates and an icon/color indicating whether "critical" updates are available.

I've made this script integration with waybar. It outputs the json based protocol for updating a custom module. It depends on (very lightweight, often found on distros by default):

• python
• sqlite
• yay
• checkupdates
• libnotify (optional: for the notify-send cli tool)
• alacritty (optional: you can use another terminal, change the on-click handler of the waybar config accordingly)

The problem it solves

With multiple display/bar setup in waybar, the program is designed such that any custom module "exec" invocation will be called once per bar. This will incur redundant AUR API calls and in worst case scenario can get user temporarily banned from executing any system upgrades. With this script "middle-man", it ensures that there are no redundant API calls by leveraging locking mechanisms and persistent storage.

Installing the script in your Arch Linux-based environment

Ensure all dependencies are installed.

Put this custom module into your waybar config:

  "custom/updates": {
    "interval": 30,
    "return-type": "json",
    "exec": "~/.config/waybar/updates.py",
    "on-click": "alacritty -e yay --noconfirm && ~/.config/waybar/updates.py --clear && pkill -RTMIN+8 waybar",
    "escape": true,
    "signal": 8,
  },

Disclaimer about the script: it does the job, it ain't perfect, there's definitely room for improvements if you're willing to tinker with it. You might especially want to configure what is considered "critical" packages as those are hard-coded in the head of the script, I've been too lazy to expose CLI command to configure it.
Place the script accordingly to waybar config($HOME/.config/waybar/updates.py).
Ensure that the script is executable(chmod +x updates.py):

#!/usr/bin/env python3

"""
This script mainly aims to tackle an "issue" in waybar where modules are called once per monitor/bar (causing unneccessary duplicate checks of updates, which can cause user to get locked out of AUR).

Summary of the script:
  - just-in-time DB/schema creation on first run
  - configurable interval in DB (default 2 h via --set-interval)
  - --set-interval SECONDS to change interval
  - --clear to reset cache timestamp (skips next interval)
  - --force to bypass interval and lock (always re-check)
  - using a file lock to serialize normal exexutions of updates (handling concurrent calls graciously)
  - skip checks when yay/pacman upgrade is in progress
  - desktop notification on new or critical updates

Usage:
Intended to be used as part of your waybar configuration:
  "custom/updates": {
    "interval": 30,
    "return-type": "json",
    "exec": "~/.config/waybar/updates.py",
    "on-click": "alacritty -e yay --noconfirm && ~/.config/waybar/updates.py --clear && pkill -RTMIN+8 waybar",
    "escape": true,
    "signal": 8,
  },
Using this configuration, the script will be called every 30 seconds, but will only check for updates based on the configured interval for the script, which is 2 hours by default.
If you click the updates module on your waybar, it will upgrade the system using yay and then call a function in this script(--clear) that will simply clear any cached updates, and
next check will happen when the script is called again and the configured interval has passed.
"""

import argparse
import fcntl
import json
import sqlite3
import subprocess
import time
from pathlib import Path

DEFAULT_INTERVAL_SECONDS = 2 * 3600
CACHE_DIR        = Path.home() / ".cache" / "waybar"
DB_PATH          = CACHE_DIR / "updates.db"
LOCK_PATH        = CACHE_DIR / "updates.lock"
KEY_UPD          = "updates"
KEY_INT          = "interval"
CRITICAL_PKGS    = {"linux-cachyos", "librewolf-bin"}


def parse_args():
    p = argparse.ArgumentParser()
    p.add_argument("--force", action="store_true",
                   help="bypass lock & interval; always re-check")
    p.add_argument("--clear", action="store_true",
                   help="under lock: reset cache timestamp to now")
    p.add_argument("--set-interval", type=int, metavar="SECONDS",
                   help="set new cache interval (CLI only)")
    return p.parse_args()


def db_init():
    db_exists = DB_PATH.exists()
    conn = sqlite3.connect(str(DB_PATH), timeout=10)
    if not db_exists:
        db_create_schema(conn)
    return conn


def db_create_schema(conn):
    """Initialize DB schema and default interval on first run."""
    conn.execute("PRAGMA journal_mode=WAL;")
    conn.execute("PRAGMA synchronous=NORMAL;")
    conn.execute("""
      CREATE TABLE IF NOT EXISTS cache (
        key       TEXT PRIMARY KEY,
        timestamp INTEGER NOT NULL,
        data      TEXT    NOT NULL
      );
    """)
    conn.execute("""
      CREATE TABLE IF NOT EXISTS config (
        key   TEXT PRIMARY KEY,
        value TEXT NOT NULL
      );
    """)
    conn.execute(
        "INSERT OR IGNORE INTO config(key,value) VALUES(?,?);",
        (KEY_INT, str(DEFAULT_INTERVAL_SECONDS))
    )
    conn.commit()


def ensure_dirs():
    """Ensure cache directory exists."""
    CACHE_DIR.mkdir(parents=True, exist_ok=True)


def read_cache(conn):
    return conn.execute(
        "SELECT timestamp,data FROM cache WHERE key=?;",
        (KEY_UPD,)
    ).fetchone()


def write_cache(conn, ts, blob):
    conn.execute(
        "REPLACE INTO cache(key,timestamp,data) VALUES(?,?,?);",
        (KEY_UPD, ts, blob)
    )
    conn.commit()


def read_interval(conn):
    row = conn.execute(
        "SELECT value FROM config WHERE key=?;",
        (KEY_INT,)
    ).fetchone()
    return int(row[0]) if row and row[0].isdigit() else DEFAULT_INTERVAL_SECONDS


def write_interval(conn, sec):
    conn.execute(
        "REPLACE INTO config(key,value) VALUES(?,?);",
        (KEY_INT, str(sec),)
    )
    conn.commit()


def run_checks():
    outs = []
    for cmd in (["checkupdates"], ["yay", "-Qua"]):
        try:
            out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL, text=True)
            if out.strip():
                outs.append(out.strip())
        except subprocess.CalledProcessError:
            continue
    return "\n".join(outs)


def upgrade_in_progress():
    for name in ("yay", "pacman"):
        try:
            subprocess.check_output(["pgrep", "-x", name], stderr=subprocess.DEVNULL)
            return True
        except subprocess.CalledProcessError:
            continue
    return False


def classify(lines):
    for l in lines:
        pkg = l.split()[0]
        if pkg in CRITICAL_PKGS:
            return "critical"
    return "ok" if lines else ""


def run_notify(msg, icon):
    try:
        subprocess.run(["notify-send", "-a", f"System updates {icon}", msg], check=False, stderr=subprocess.DEVNULL)
    except subprocess.CalledProcessError:
        pass


def handle_set_interval(conn, args):
    if args.set_interval is not None:
        write_interval(conn, args.set_interval)
        return True, f"Interval set to {args.set_interval} seconds"
    return False, None


def handle_clear(conn, args):
    if args.clear:
        now = int(time.time())
        with open(LOCK_PATH, "w") as lf:
            fcntl.flock(lf, fcntl.LOCK_EX)
            write_cache(conn, now, json.dumps({"ts": now, "out": ""}))
        return True, json.dumps({"text": "", "class": ""})
    return False, None


def handle_updates(conn, args):
    now = int(time.time())
    updated = False
    if args.force:
        raw = run_checks()
        write_cache(conn, now, json.dumps({"ts": now, "out": raw}))
        data = {"ts": now, "out": raw}
        updated = True
    else:
        interval = read_interval(conn)
        with open(LOCK_PATH, "w") as lf:
            fcntl.flock(lf, fcntl.LOCK_EX)
            row = read_cache(conn)
            if upgrade_in_progress():
                data = json.loads(row[1]) if row else {"ts": now, "out": ""}
            else:
                if row is None or (now - row[0]) > interval:
                    raw = run_checks()
                    write_cache(conn, now, json.dumps({"ts": now, "out": raw}))
                    data = {"ts": now, "out": raw}
                    updated = True
                else:
                    data = json.loads(row[1])

    lines = data["out"].splitlines() if data["out"].strip() else []
    status = classify(lines)
    num = len(lines)
    icon = "" if status == "critical" else ""
    text = f"{num} {icon} " if num else ""

    if (updated or args.force) and num > 0:
        run_notify(f"{num} packages", icon)

    return json.dumps({"text": text, "class": status})


def main():
    args = parse_args()
    ensure_dirs()
    conn = db_init()

    handled, output = handle_set_interval(conn, args)
    if not handled:
        handled, output = handle_clear(conn, args)
        if not handled:
            output = handle_updates(conn, args)

    conn.close()

    if output is not None:
        print(output)


if __name__ == "__main__":
    main()

Finally here is the CSS that I am personally alongside with it, but you could probably make it a lot nicer than me:

#custom-updates {
  padding: 0 10px;
  color: #ffffff;
  margin-left: 5px;
  margin-right: 5px;
  background-color: rgba(176, 176, 0, 0.2);
  border-radius: 10px;
  box-shadow: inset 0 -3px yellow;
}

#custom-updates:hover {
  background-color: rgba(176, 176, 0, 0.5);
}

#custom-updates.critical {
  background-color: rgba(176, 0, 0, 0.2);
  box-shadow: inset 0 -3px red;
}

#custom-updates.critical:hover {
  background-color: rgba(176, 0, 0, 0.5);
}