import QtQuick import Quickshell import Quickshell.Io import "sysinfo.js" as Sys import "resources.js" as Res import "system-problems.js" as Problems // Thin I/O + cadence service over the pure sysinfo.js core. // All parsing / issue-detection logic lives in sysinfo.js; this file only does // file reads, process spawns, timers, and exposes reactive properties. Item { id: root // --- injected services (DI via shell.qml; never singletons here) --- required property var powerProfiles // PowerProfiles singleton (degradationReason) // --- view-bound live properties (fast loop) --- // Open-popup refresh cadence; isolated fixtures shorten it, production keeps 5 s. property int slowRefreshMs: 5000 // Shown-sample cadence; isolated fixtures shorten it, production keeps 2 s. property int liveSampleMs: 2000 // Closed cadences: cheap /proc and /sys reads for the backdrop and the bar chip, // and the failed-service and disk check behind the chip's attention. property int closedSampleMs: 10000 property int closedCheckMs: 60000 // Another surface shows the network rates (the connectivity panel): sample // at the open cadence, without history. property bool liveRates: false property real cpuUsage: 0 property real memoryUsage: 0 property real swapUsage: 0 property real memTotal: 0 property real memAvailable: 0 property real swapTotal: 0 property real swapFree: 0 property real networkRxRate: 0 property real networkTxRate: 0 property real diskReadRate: 0 property real diskWriteRate: 0 // nullable: no sensor -> null (view shows n/a, thermal check skipped) property var cpuTemperatureC: null property var fanRpm: null property real loadOne: 0 property real loadFive: 0 property real loadFifteen: 0 property int cores: 1 // --- ring buffers for sparklines, filled only while the popup is open and // restarted on each opening (cap = samples the widest spark shows; // 160 × 2s ≈ 5 min of history) --- readonly property int ringCap: 160 property var cpuRing: [] property var memRing: [] property var tempRing: [] property var netRxRing: [] // download, for the directional net spark property var netTxRing: [] // upload, for the directional net spark property var diskReadRing: [] // read, for the directional disk spark property var diskWriteRing: [] // write, for the directional disk spark // --- issue inputs (slow / rare loops) --- property var failedUnits: [] property var incidents: [] property string incidentStatus: "not checked" property string agentIssueId: "" property string agentError: "" property var pendingAgent: ({}) signal agentDispatched property bool agentPromptLoading: false readonly property bool agentPending: agentPromptLoading || agentCheck.running property var diskUsage: [] // [{source,target,usedPercent}] property var updateCount: null // null = unknown / n/a property bool swapGrowing: false // thermal high threshold; resolved from sensor max/crit on start, default 87 property real tempHighC: 87 // aurora "firestorm" intensity, consumed by AuroraBackdrop.qml. A continuous // 0..1 ramp as CPU temp climbs the last 12°C toward the thermal threshold — // replaces the old hot/cool hysteresis counters. null temp => 0 (calm). readonly property real firestormTarget: { if (cpuTemperatureC === null || cpuTemperatureC === undefined) return 0; const t = Number(cpuTemperatureC); if (!isFinite(t)) return 0; const high = Math.max(1, tempHighC); const cool = high - 12; return Math.max(0, Math.min(1, (t - cool) / (high - cool))); } // --- top processes (slow loop, only while popup open) --- property var processes: [] // --- identity facts (rare loop, cached) --- property var identity: ({}) property bool identityLoaded: false // --- popup lifecycle gate (set by the registry entry) --- property bool popupOpen: false // Power owns native battery shaping; the registry forwards these issue inputs. // Null health / charge skips battery checks on desktops and unsupported devices. property var healthPercentage: null property bool isLaptopBattery: false property var batteryPercent: null property string batteryStatus: "" readonly property var degradationReason: { if (!powerProfiles) return null; const r = powerProfiles.degradationReason; return (r === null || r === undefined) ? null : String(r); } // --- last issue action record (for IPC introspection) --- property var lastAction: ({}) // --- internal delta state --- property var prevCpu: null property real prevNetRx: 0 property real prevNetTx: 0 property real prevDiskRead: 0 property real prevDiskWrite: 0 property real prevRateTime: 0 property real prevSwapUsed: 0 property var failedSystemUnits: [] property var failedUserUnits: [] // --- sample loop: pure /proc + /sys reads and deltas; every 2 s while shown, // every 10 s while only the backdrop and bar chip read them; rings only while open --- function refreshFast() { statFile.reload(); const statText = statFile.text() || ""; const cd = Sys.cpuDelta(prevCpu, statText); cpuUsage = cd.usage; prevCpu = cd.next; const coreLines = statText.match(/^cpu[0-9]/gm); if (coreLines && coreLines.length > 0) cores = coreLines.length; meminfoFile.reload(); const mem = Sys.parseMeminfo(meminfoFile.text() || ""); if (mem.memTotal > 0) { memTotal = mem.memTotal; memAvailable = mem.memAvailable; swapTotal = mem.swapTotal; swapFree = mem.swapFree; memoryUsage = mem.memoryUsage; swapUsage = mem.swapUsage; const swapUsed = Math.max(0, mem.swapTotal - mem.swapFree); swapGrowing = swapUsed > prevSwapUsed + 1; prevSwapUsed = swapUsed; } netFile.reload(); diskFile.reload(); const net = Sys.parseNetDev(netFile.text() || ""); const disk = Sys.parseDiskstats(diskFile.text() || ""); const now = Date.now(); const seconds = prevRateTime > 0 ? Math.max(0.2, (now - prevRateTime) / 1000) : 0; if (seconds > 0) { networkRxRate = Sys.rate(prevNetRx, net.rx, seconds); networkTxRate = Sys.rate(prevNetTx, net.tx, seconds); diskReadRate = Sys.rate(prevDiskRead, disk.readBytes, seconds); diskWriteRate = Sys.rate(prevDiskWrite, disk.writeBytes, seconds); } prevNetRx = net.rx; prevNetTx = net.tx; prevDiskRead = disk.readBytes; prevDiskWrite = disk.writeBytes; prevRateTime = now; loadFile.reload(); const loadText = loadFile.text() || ""; if (loadText.trim().length > 0) { const la = Sys.parseLoadavg(loadText); loadOne = la.one; loadFive = la.five; loadFifteen = la.fifteen; } // hwmon temp + fan; keep last-good on null/parse failure if (tempFile.path) { tempFile.reload(); const t = Sys.parseTemp(tempFile.text() || ""); if (t !== null) cpuTemperatureC = t; } if (fanFile.path) { fanFile.reload(); const f = Sys.parseFan(fanFile.text() || ""); if (f !== null) fanRpm = f; } if (!popupOpen) return; cpuRing = Sys.pushRing(cpuRing, cpuUsage, ringCap); memRing = Sys.pushRing(memRing, memoryUsage, ringCap); if (cpuTemperatureC !== null) tempRing = Sys.pushRing(tempRing, cpuTemperatureC, ringCap); netRxRing = Sys.pushRing(netRxRing, networkRxRate, ringCap); netTxRing = Sys.pushRing(netTxRing, networkTxRate, ringCap); diskReadRing = Sys.pushRing(diskReadRing, diskReadRate, ringCap); diskWriteRing = Sys.pushRing(diskWriteRing, diskWriteRate, ringCap); } // --- check loop: process spawns; failed services and disk use every 5 s while // open and every minute while closed, for the bar chip; journal and top // processes only while open --- function refreshSlow() { if (!failedSystemProc.running) failedSystemProc.exec(["systemctl", "--failed", "--no-legend", "--plain"]); if (!failedUserProc.running) failedUserProc.exec(["systemctl", "--user", "--failed", "--no-legend", "--plain"]); if (!dfProc.running) dfProc.exec(["df", "-P"]); if (!popupOpen) return; if (!incidentProc.running) incidentProc.exec(Problems.journalCommand()); if (!psProc.running) psProc.exec(["sh", "-c", "ps -eo pid=,comm=,pcpu=,pmem= --sort=-pcpu | head -n 5"]); } // --- rare loop: identity facts (cached) + checkupdates (async, on open) --- function refreshRare() { if (!identityLoaded && !identityProc.running) identityProc.exec(["sh", "-c", "printf 'host=%s\\n' \"$(uname -n)\"; printf 'kernel=%s\\n' \"$(uname -r)\"; ( . /etc/os-release 2>/dev/null; printf 'distro=%s\\n' \"${PRETTY_NAME:-Linux}\" ); printf 'model=%s\\n' \"$(cat /sys/devices/virtual/dmi/id/product_version 2>/dev/null || cat /sys/devices/virtual/dmi/id/product_name 2>/dev/null)\"; printf 'shell=%s\\n' \"$(basename \"${SHELL:-sh}\")\"; printf 'uptime=%s\\n' \"$(uptime -p 2>/dev/null | sed 's/^up //')\"; printf 'packages=%s\\n' \"$(pacman -Qq 2>/dev/null | wc -l)\""]); if (!updatesProc.running) updatesProc.exec(["checkupdates"]); } function recomputeFailed() { failedUnits = failedSystemUnits.concat(failedUserUnits); } // --- assemble detectIssues input (keys MUST match the sysinfo.js contract) --- function buildIssueState() { return { "failedUnits": failedUnits, "failedScopes": [ { scope: "system", units: failedSystemUnits }, { scope: "user", units: failedUserUnits } ], "cpuTemperatureC": cpuTemperatureC, "tempHighC": tempHighC, "degradationReason": degradationReason, "diskUsage": diskUsage, "memoryUsage": memoryUsage, "swapGrowing": swapGrowing, "healthPercentage": healthPercentage, "isLaptopBattery": isLaptopBattery, "loadOne": loadOne, "cores": cores, "updateCount": updateCount }; } // Current conditions, re-derived when a metric they read changes. readonly property var conditions: Sys.detectIssues(buildIssueState()) // The bar chip's emphasis: "error", "warning", or "" for none. readonly property string attention: Sys.attention(conditions) // Journal history, regrouped only when a journal refresh lands. readonly property var incidentGroups: Problems.groupIncidents(incidents) function issues() { return conditions.concat(incidentGroups); } // The panel's retry after unreadable history: read the journal again now, // pending until the result lands. function retryIncidents(): void { incidentStatus = "not checked"; if (!incidentProc.running) incidentProc.exec(Problems.journalCommand()); } // click-to-act: pure planner decides argv; QML only launches. function runIssueAction(id) { const result = Res.issueAction(issues(), id); if (!result.ok) return JSON.stringify(result); lastAction = result; Quickshell.execDetached(result.argv); return JSON.stringify(lastAction); } function runIssueAgent(id) { if (agentPending) return; const issue = issues().find(entry => entry.id === String(id)); if (!Res.agentAllowed(issue)) return; agentIssueId = String(id); agentError = ""; agentPromptLoading = true; repairPrompt.reload(); } function prepareIssueAgent(template: string): void { const plan = Res.agentAction(issues(), agentIssueId, { home: Quickshell.env("HOME"), stateHome: Quickshell.env("XDG_STATE_HOME"), observedAt: new Date().toISOString(), identity: identity }, template); agentPromptLoading = false; if (!plan.ok) { agentError = plan.reason === "prompt-invalid" ? "repair prompt unavailable or invalid" : plan.reason === "home-unavailable" ? "home directory unavailable" : "issue no longer eligible"; return; } pendingAgent = plan; // Fixed script only; no issue text ever enters shell syntax. // File transport preserves all retained occurrences without Linux's // per-argument size limit. Requests are private, immutable repair evidence. agentCheck.stdinEnabled = true; agentCheck.exec(["sh", "-c", "command -v pi || { cat >/dev/null; exit 75; }; command -v wezterm || { cat >/dev/null; exit 76; }; umask 077; mkdir -p -- \"$1\" && test -d \"$1\" && test -w \"$1\" && test -x \"$1\" || { cat >/dev/null; exit 73; }; request=$(mktemp -- \"$1/.request-XXXXXX.md\") || { cat >/dev/null; exit 74; }; cat >\"$request\" || { rm -- \"$request\"; exit 74; }; printf '%s\\n' \"${request##*/}\"", "nuguland-repairs", plan.argv[3]]); } // --- IPC and diagnostics contract --- function stateJson() { const memUsed = Math.max(0, memTotal - memAvailable); const swapUsed = Math.max(0, swapTotal - swapFree); return JSON.stringify({ "kind": "system", "title": "system", "popupOpen": popupOpen, "cpu": { "usage": cpuUsage, "percent": Math.round(cpuUsage * 100) }, "memory": { "usage": memoryUsage, "percent": Math.round(memoryUsage * 100), "used": memUsed, "total": memTotal, "label": `${Sys.formatBytes(memUsed)} / ${Sys.formatBytes(memTotal)}` }, "swap": { "usage": swapUsage, "percent": Math.round(swapUsage * 100), "used": swapUsed, "total": swapTotal, "label": swapTotal > 0 ? `${Sys.formatBytes(swapUsed)} / ${Sys.formatBytes(swapTotal)}` : "off" }, "network": { "rxRate": networkRxRate, "txRate": networkTxRate, "label": `↓ ${Sys.formatRate(networkRxRate)} ↑ ${Sys.formatRate(networkTxRate)}` }, "disk": { "readRate": diskReadRate, "writeRate": diskWriteRate, "label": `R ${Sys.formatRate(diskReadRate)} W ${Sys.formatRate(diskWriteRate)}` }, "temperature": { "celsius": cpuTemperatureC, "highThresholdC": tempHighC, "label": cpuTemperatureC !== null ? `${Math.round(Number(cpuTemperatureC))}°C` : "n/a" }, "fan": { "rpm": fanRpm, "label": fanRpm !== null ? `${Math.round(Number(fanRpm))} rpm` : "n/a" }, "load": { "one": loadOne, "five": loadFive, "fifteen": loadFifteen, "cores": cores }, "battery": { "percent": batteryPercent, "status": batteryStatus, "healthPercentage": healthPercentage, "isLaptopBattery": isLaptopBattery }, "identity": identity, "updateCount": updateCount, "processes": processes, "issues": issues(), "lastAction": lastAction }); } Component.onCompleted: { // resolve hwmon temp (coretemp package) + fan (thinkpad) paths once. hwmonResolve.exec(["sh", "-c", "for d in /sys/class/hwmon/hwmon*; do n=$(cat \"$d/name\" 2>/dev/null); if [ \"$n\" = coretemp ]; then for t in \"$d\"/temp*_label; do [ -r \"$t\" ] || continue; if grep -qi package \"$t\"; then b=${t%_label}; [ -r \"${b}_input\" ] && printf 'temp=%s\\n' \"${b}_input\"; if [ -r \"${b}_max\" ]; then printf 'high=%s\\n' \"$(cat ${b}_max)\"; elif [ -r \"${b}_crit\" ]; then printf 'high=%s\\n' \"$(cat ${b}_crit)\"; fi; break; fi; done; elif [ \"$n\" = thinkpad ]; then [ -r \"$d/fan1_input\" ] && printf 'fan=%s\\n' \"$d/fan1_input\"; fi; done"]); } // --- FileViews: pure reads, last-good on failure (printErrors off) --- FileView { id: statFile path: "/proc/stat" blockLoading: true printErrors: false } FileView { id: meminfoFile path: "/proc/meminfo" blockLoading: true printErrors: false } FileView { id: netFile path: "/proc/net/dev" blockLoading: true printErrors: false } FileView { id: diskFile path: "/proc/diskstats" blockLoading: true printErrors: false } FileView { id: loadFile path: "/proc/loadavg" blockLoading: true printErrors: false } // paths resolved at runtime by hwmonResolve; empty until then. FileView { id: tempFile path: "" blockLoading: true printErrors: false } FileView { id: fanFile path: "" blockLoading: true printErrors: false } // --- one-shot hwmon path resolution --- Process { id: hwmonResolve running: false stdout: StdioCollector { waitForEnd: true onStreamFinished: { const lines = String(this.text || "").split("\n"); for (let i = 0; i < lines.length; i++) { const line = lines[i].trim(); if (line.indexOf("temp=") === 0) tempFile.path = line.slice(5); else if (line.indexOf("fan=") === 0) fanFile.path = line.slice(4); else if (line.indexOf("high=") === 0) { const v = Number(line.slice(5)); if (Number.isFinite(v) && v > 0) root.tempHighC = v / 1000; } } } } } FileView { id: repairPrompt path: Qt.resolvedUrl("prompts/system-repair.md") printErrors: false onLoaded: if (root.agentPromptLoading) root.prepareIssueAgent(repairPrompt.text()) onLoadFailed: { if (root.agentPromptLoading) { root.agentPromptLoading = false; root.agentError = "repair prompt unavailable or invalid"; } } } Process { id: agentCheck stdout: StdioCollector { id: agentPaths waitForEnd: true } function handleExit(exitCode: int): void { const paths = String(agentPaths.text).trim().split("\n"); if (exitCode === 73) { root.agentError = "repair directory unavailable or not writable"; return; } if (exitCode === 74) { root.agentError = "repair context could not be saved"; return; } // A missing tool is named with its fix; the arrrgh button beside it retries. if (exitCode === 75 || exitCode === 76) { const tool = exitCode === 75 ? "pi" : "wezterm"; root.agentError = `${tool} not found · install ${tool} or add it to the session path, then retry`; return; } if (exitCode !== 0 || paths.length !== 3 || paths[0][0] !== "/" || paths[1][0] !== "/" || !/^\.request-[A-Za-z0-9]+\.md$/.test(paths[2])) { root.agentError = "repair launch check failed · retry"; return; } const argv = root.pendingAgent.argv.slice(); argv[0] = paths[1]; argv[5] = paths[0]; argv[argv.length - 1] = "@" + argv[3] + "/" + paths[2]; root.lastAction = { id: root.pendingAgent.id, kind: "agent", status: "dispatched" }; Quickshell.execDetached(argv); root.pendingAgent = ({}); root.agentDispatched(); } } // --- slow-loop processes --- Process { id: incidentProc stdout: StdioCollector { id: incidentOut waitForEnd: true } stderr: StdioCollector { id: incidentErr waitForEnd: true } function handleExit(exitCode: int): void { // No-match with --grep exits 1. Diagnostics mean incomplete visibility. const parsed = Problems.parseJournal(incidentOut.text); const empty = !String(incidentOut.text).trim(); if ((exitCode === 0 || (exitCode === 1 && empty)) && !String(incidentErr.text).trim() && parsed.ok) { root.incidents = parsed.issues; root.incidentStatus = "ready"; } else { root.incidentStatus = "history unavailable or incomplete"; } } } Process { id: failedSystemProc running: false stdout: StdioCollector { id: failedSystemOut waitForEnd: true } function handleExit(exitCode: int): void { if (exitCode === 0) { root.failedSystemUnits = Sys.parseFailedUnits(failedSystemOut.text); root.recomputeFailed(); } } } Process { id: failedUserProc running: false stdout: StdioCollector { id: failedUserOut waitForEnd: true } function handleExit(exitCode: int): void { if (exitCode === 0) { root.failedUserUnits = Sys.parseFailedUnits(failedUserOut.text); root.recomputeFailed(); } } } Process { id: dfProc running: false stdout: StdioCollector { waitForEnd: true onStreamFinished: { const parsed = Sys.parseDf(this.text); if (parsed.length > 0) root.diskUsage = parsed; } } } Process { id: psProc running: false stdout: StdioCollector { waitForEnd: true onStreamFinished: { const parsed = Sys.parsePsTop(this.text); if (parsed.length > 0) root.processes = parsed; } } } // --- rare-loop processes --- Process { id: identityProc running: false stdout: StdioCollector { waitForEnd: true onStreamFinished: { const out = { "wm": "niri" }; const lines = String(this.text || "").split("\n"); for (let i = 0; i < lines.length; i++) { const eq = lines[i].indexOf("="); if (eq <= 0) continue; out[lines[i].slice(0, eq)] = lines[i].slice(eq + 1).trim(); } if (out.host) { root.identity = out; root.identityLoaded = true; } } } } Process { id: updatesProc running: false stdout: StdioCollector { id: updatesOut waitForEnd: true } // checkupdates: 0 = updates listed, 2 = none, other = error / no network. function handleExit(exitCode: int): void { if (exitCode === 2) { root.updateCount = 0; return; } if (exitCode !== 0) { root.updateCount = null; return; } const lines = String(updatesOut.text || "").split("\n").filter(l => { return l.trim().length > 0; }); root.updateCount = lines.length; } } // Explicit Connections register real handlers without requiring the missing // QProcess::ExitStatus enum in Quickshell's installed qmltypes metadata. Connections { target: agentCheck function onStarted(): void { const argv = root.pendingAgent.argv; agentCheck.write(argv[argv.length - 1]); agentCheck.stdinEnabled = false; } function onExited(exitCode: int): void { agentCheck.handleExit(exitCode); } } Connections { target: incidentProc function onExited(exitCode: int): void { incidentProc.handleExit(exitCode); } } Connections { target: failedSystemProc function onExited(exitCode: int): void { failedSystemProc.handleExit(exitCode); } } Connections { target: failedUserProc function onExited(exitCode: int): void { failedUserProc.handleExit(exitCode); } } Connections { target: updatesProc function onExited(exitCode: int): void { updatesProc.handleExit(exitCode); } } // --- cadence timers --- // A changed interval restarts a running timer without triggering it; // opening samples at once and restarts the sparkline history. onPopupOpenChanged: { if (!popupOpen) return; cpuRing = []; memRing = []; tempRing = []; netRxRing = []; netTxRing = []; diskReadRing = []; diskWriteRing = []; refreshFast(); refreshSlow(); } onLiveRatesChanged: if (liveRates) refreshFast() Timer { id: fastTimer interval: root.popupOpen || root.liveRates ? root.liveSampleMs : root.closedSampleMs repeat: true running: true triggeredOnStart: true onTriggered: root.refreshFast() } Timer { id: slowTimer interval: root.popupOpen ? root.slowRefreshMs : root.closedCheckMs repeat: true running: true triggeredOnStart: true onTriggered: root.refreshSlow() } Timer { id: rareTimer interval: 300000 repeat: true running: root.popupOpen triggeredOnStart: true onTriggered: root.refreshRare() } }