Add ArchUpdater widget and service; update settings for Arch updates

Services/ArchUpdaterService.qml

@@ -0,0 +1,222 @@
+pragma Singleton
+import Quickshell
+import QtQuick
+import Quickshell.Io
+import qs.Commons
+
+Singleton {
+    id: updateService
+    property bool isArchBased: false
+    property bool checkupdatesAvailable: false
+    readonly property bool ready: isArchBased && checkupdatesAvailable
+    readonly property bool busy: pkgProc.running
+    readonly property int updates: updatePackages.length
+    property var updatePackages: []
+    property double lastSync: 0
+    property bool lastWasFull: false
+    property int failureCount: 0
+    readonly property int failureThreshold: 5
+    readonly property int quickTimeoutMs: 12 * 1000
+    readonly property int minuteMs: 60 * 1000
+    readonly property int pollInterval: 1 * minuteMs
+    readonly property int syncInterval: 15 * minuteMs
+    property int lastNotifiedUpdates: 0
+
+    property var updateCommand: ["xdg-terminal-exec", "--title=System Updates", "-e", "sh", "-c", "sudo pacman -Syu; printf '\n\nUpdate finished. Press Enter to exit...'; read _"]
+
+    PersistentProperties {
+        id: cache
+        reloadableId: "ArchCheckerCache"
+
+        property string cachedUpdatePackagesJson: "[]"
+        property double cachedLastSync: 0
+    }
+
+    Component.onCompleted: {
+        const persisted = JSON.parse(cache.cachedUpdatePackagesJson || "[]");
+        if (persisted.length)
+            updatePackages = _clonePackageList(persisted);
+        if (cache.cachedLastSync > 0)
+            lastSync = cache.cachedLastSync;
+    }
+
+    function runUpdate() {
+        if (updates > 0) {
+            Quickshell.execDetached(updateCommand);
+        } else {
+            doPoll(true);
+        }
+    }
+
+    function notify(title, body) {
+        const app = "UpdateService";
+        const icon = "system-software-update";
+        Quickshell.execDetached(["notify-send", "-a", app, "-i", icon, String(title || ""), String(body || "")]);
+    }
+
+    function startUpdateProcess(cmd) {
+        pkgProc.command = cmd;
+        pkgProc.running = true;
+        killTimer.interval = lastWasFull ? 60 * 1000 : minuteMs;
+        killTimer.restart();
+    }
+
+    function doPoll(forceFull = false) {
+        if (busy)
+            return;
+        const full = forceFull || (Date.now() - lastSync > syncInterval);
+        lastWasFull = full;
+
+        pkgProc.command = full ? ["checkupdates", "--nocolor"] : ["checkupdates", "--nosync", "--nocolor"];
+        pkgProc.running = true;
+        killTimer.restart();
+    }
+
+    Process {
+        id: pacmanCheck
+        running: true
+        command: ["sh", "-c", "p=$(command -v pacman >/dev/null && echo yes || echo no); c=$(command -v checkupdates >/dev/null && echo yes || echo no); echo \"$p $c\""]
+        stdout: StdioCollector {
+            onStreamFinished: {
+                const parts = (text || "").trim().split(/\s+/);
+                updateService.isArchBased = (parts[0] === "yes");
+                updateService.checkupdatesAvailable = (parts[1] === "yes");
+                if (updateService.ready) {
+                    updateService.doPoll();
+                    pollTimer.start();
+                }
+            }
+        }
+    }
+
+    Process {
+        id: pkgProc
+        onExited: function (exitCode, exitStatus) {
+            killTimer.stop();
+            if (exitCode !== 0 && exitCode !== 2) {
+                updateService.failureCount++;
+                Logger.warn("UpdateService", `checkupdates failed (code: ${exitCode}, status: ${exitStatus})`);
+                if (updateService.failureCount >= updateService.failureThreshold) {
+                    updateService.notify(qsTr("Update check failed"), qsTr(`Exit code: ${exitCode} (failed ${updateService.failureCount} times)`));
+                    updateService.failureCount = 0;
+                }
+                updateService.updatePackages = [];
+            }
+        }
+
+        stdout: StdioCollector {
+            id: out
+            onStreamFinished: {
+                if (!pkgProc.running || updateService.busy)
+                    return;
+                killTimer.stop();
+
+                const parsed = updateService._parseUpdateOutput(out.text);
+                updateService.updatePackages = parsed.pkgs;
+
+                if (updateService.lastWasFull) {
+                    updateService.lastSync = Date.now();
+                }
+
+                cache.cachedUpdatePackagesJson = JSON.stringify(updateService._clonePackageList(updateService.updatePackages));
+                cache.cachedLastSync = updateService.lastSync;
+                updateService._summarizeAndNotify(parsed.pkgs, updateService.updates);
+            }
+        }
+        stderr: StdioCollector {
+            id: err
+            onStreamFinished: {
+                const stderrText = (err.text || "").trim();
+                if (stderrText) {
+                    Logger.warn("UpdateService", "stderr:", stderrText);
+                    updateService.failureCount++;
+                    updateService._notifyOnFailureThreshold(stderrText);
+                } else {
+                    updateService.failureCount = 0;
+                }
+            }
+        }
+    }
+
+    function _notifyOnFailureThreshold(body) {
+        if (failureCount >= failureThreshold) {
+            notify(qsTr("Update check failed"), String(body || ""));
+            failureCount = 0;
+            return true;
+        }
+        return false;
+    }
+
+    function _clonePackageList(list) {
+        const src = Array.isArray(list) ? list : [];
+        return src.map(p => ({
+                    name: String(p.name || ""),
+                    oldVersion: String(p.oldVersion || ""),
+                    newVersion: String(p.newVersion || "")
+                }));
+    }
+
+    function _parseUpdateOutput(rawText) {
+        const raw = (rawText || "").trim();
+        const lines = raw ? raw.split(/\r?\n/) : [];
+        const pkgs = [];
+        for (let i = 0; i < lines.length; ++i) {
+            const m = lines[i].match(/^(\S+)\s+([^\s]+)\s+->\s+([^\s]+)$/);
+            if (m) {
+                pkgs.push({
+                    name: m[1],
+                    oldVersion: m[2],
+                    newVersion: m[3]
+                });
+            }
+        }
+        return {
+            raw,
+            pkgs
+        };
+    }
+
+    function _summarizeAndNotify() {
+        if (updates === 0) {
+            lastNotifiedUpdates = 0;
+            return;
+        }
+        if (updates <= lastNotifiedUpdates)
+            return;
+        const added = updates - lastNotifiedUpdates;
+        const msg = added === 1 ? qsTr("One new package can be upgraded (") + updates + qsTr(")") : `${added} ${qsTr("new packages can be upgraded (")} ${updates} ${qsTr(")")}`;
+        notify(qsTr("Updates Available"), msg);
+        lastNotifiedUpdates = updates;
+    }
+
+    Timer {
+        id: pollTimer
+        interval: updateService.pollInterval
+        repeat: true
+        onTriggered: {
+            if (!updateService.ready)
+                return;
+            updateService.doPoll();
+        }
+    }
+
+    Timer {
+        id: killTimer
+        interval: updateService.lastWasFull ? updateService.minuteMs : updateService.quickTimeoutMs
+        repeat: false
+        onTriggered: {
+            if (pkgProc.running) {
+                Logger.error("UpdateService", "Update check killed (timeout)");
+                updateService.notify(qsTr("Update check killed"), qsTr("Process took too long"));
+            }
+        }
+    }
+
+    onUpdatePackagesChanged: {
+        cache.cachedUpdatePackagesJson = JSON.stringify(_clonePackageList(updatePackages));
+    }
+
+    onLastSyncChanged: {
+        cache.cachedLastSync = lastSync;
+    }
+}