@xynogen/pix-runtime 0.17.0 → 0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-runtime",
-	"version": "0.17.0",
+	"version": "0.17.1",
 	"description": "Pix shared runtime — versioned pix.json config, atomic persistence, typed change events",
 	"type": "module",
 	"main": "src/index.ts",
@@ -69,6 +69,7 @@
 		"@ast-grep/napi": "^0.45.0"
 	},
 	"dependencies": {
+		"systeminformation": "5.33.19",
 		"xxhash-wasm": "1.1.0"
 	},
 	"peerDependenciesMeta": {

package/src/sysstat.ts

@@ -1,118 +1,69 @@
-/**
- * sysstat.ts — cheap host load sample for status bars: CPU %, RAM %, GPU %, CPU temperature.
- *
- * CPU and RAM come from `node:os`, so they work on every OS. GPU busy % and temperature
- * are read from Linux sysfs (`/sys/class/drm`, `/sys/class/hwmon`, `/sys/class/thermal`);
- * elsewhere, or when the driver exposes nothing, those fields are undefined.
- * ponytail: no NVIDIA support (its driver has no sysfs busy file). Add an `nvidia-smi`
- * catalog binary and a slow poll here if that is needed.
- */
-
-import { readdirSync, readFileSync } from "node:fs";
-import { cpus, freemem, totalmem } from "node:os";
-import { join } from "node:path";
+import { promises as fs } from "node:fs";
+import si from "systeminformation";
 
 export interface SystemStats {
-	/** Busy CPU since the previous sample, 0–100. Undefined on the first sample. */
 	cpu?: number;
-	/** Used memory (total − available), 0–100. */
-	ram?: number;
-	/** GPU busy, 0–100 (Linux amdgpu/i915/xe sysfs only). */
+	cpuTemp?: number;
 	gpu?: number;
-	/** CPU package temperature in °C (Linux hwmon/thermal only). */
-	temp?: number;
-}
-
-/** Opaque CPU counter snapshot; pass the previous one to get a CPU percent. */
-export type CpuTimes = { busy: number; total: number };
-
-export function cpuTimes(): CpuTimes {
-	let busy = 0;
-	let total = 0;
-	for (const { times } of cpus()) {
-		const sum = times.user + times.nice + times.sys + times.idle + times.irq;
-		total += sum;
-		busy += sum - times.idle;
-	}
-	return { busy, total };
-}
-
-/** Busy share between two snapshots, 0–100, or undefined when no time passed. */
-export function cpuPercent(prev: CpuTimes, next: CpuTimes): number | undefined {
-	const total = next.total - prev.total;
-	if (total <= 0) return undefined;
-	return clampPct(((next.busy - prev.busy) / total) * 100);
-}
-
-const clampPct = (n: number) => Math.min(100, Math.max(0, Math.round(n)));
-
-function readNumber(path: string): number | undefined {
-	try {
-		const n = Number(readFileSync(path, "utf8").trim());
-		return Number.isFinite(n) ? n : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function list(dir: string): string[] {
-	try {
-		return readdirSync(dir);
-	} catch {
-		return [];
-	}
-}
-
-/** Highest `gpu_busy_percent` across DRM cards (a laptop may report an idle iGPU too). */
-export function readGpuBusy(sys = "/sys"): number | undefined {
-	let best: number | undefined;
-	for (const card of list(join(sys, "class/drm"))) {
-		if (!/^card\d+$/.test(card)) continue;
-		const n = readNumber(join(sys, "class/drm", card, "device/gpu_busy_percent"));
-		if (n !== undefined) best = Math.max(best ?? 0, clampPct(n));
-	}
-	return best;
+	gpuTemp?: number;
+	ram?: number;
 }
 
-// CPU sensor drivers, most specific first. coretemp = Intel, k10temp/zenpower = AMD.
-const CPU_HWMON = ["k10temp", "zenpower", "coretemp", "cpu_thermal", "acpitz"];
+/** Missing sensors, sentinel values and failed probes stay unavailable, never become zero. */
+const reading = (value: unknown, max: number): number | undefined =>
+	typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= max
+		? Math.round(value)
+		: undefined;
 
-/** CPU temperature in °C from hwmon (known CPU drivers), then thermal_zone0. */
-export function readCpuTemp(sys = "/sys"): number | undefined {
-	const hwmon = join(sys, "class/hwmon");
-	const byName = new Map<string, string>();
-	for (const dir of list(hwmon)) {
-		try {
-			byName.set(readFileSync(join(hwmon, dir, "name"), "utf8").trim(), dir);
-		} catch {}
+async function readAmdStats(): Promise<SystemStats> {
+	const stats: SystemStats = {};
+	const read = (path: string) => fs.readFile(path, "utf8").catch(() => "");
+	const cards = await fs.readdir("/sys/class/drm").catch(() => []);
+	for (const card of cards.filter((name) => /^card\d+$/.test(name))) {
+		const device = `/sys/class/drm/${card}/device`;
+		if ((await read(`${device}/vendor`)).trim() !== "0x1002") continue;
+		const busy = (await read(`${device}/gpu_busy_percent`)).trim();
+		const gpu = busy ? reading(Number(busy), 100) : undefined;
+		if (gpu !== undefined) stats.gpu = Math.max(stats.gpu ?? 0, gpu);
+		const sensors = await fs.readdir(`${device}/hwmon`).catch(() => []);
+		for (const sensor of sensors) {
+			const raw = (await read(`${device}/hwmon/${sensor}/temp1_input`)).trim();
+			const temperature = raw ? reading(Number(raw) / 1000, 150) : undefined;
+			if (temperature !== undefined) stats.gpuTemp = Math.max(stats.gpuTemp ?? 0, temperature);
+		}
 	}
-	for (const name of CPU_HWMON) {
-		const dir = byName.get(name);
-		const milli = dir && readNumber(join(hwmon, dir, "temp1_input"));
-		if (milli) return Math.round(milli / 1000);
-	}
-	const zone = readNumber(join(sys, "class/thermal/thermal_zone0/temp"));
-	return zone ? Math.round(zone / 1000) : undefined;
+	return stats;
 }
 
-/**
- * Take one sample. Keep the returned `times` and pass it back next call so CPU % covers
- * the interval between calls. Synchronous and cheap (a few small sysfs reads).
- */
-export function readSystemStats(
-	prev?: CpuTimes,
-	sys = "/sys",
-): { stats: SystemStats; times: CpuTimes } {
-	const times = cpuTimes();
-	const total = totalmem();
-	const linux = process.platform === "linux";
+/** Read each source independently so an unsupported sensor cannot discard other readings. */
+export async function readSystemStats(): Promise<SystemStats> {
+	const [cpu, temperature, graphics, memory] = await Promise.allSettled([
+		si.currentLoad(),
+		si.cpuTemperature(),
+		si.graphics(),
+		si.mem(),
+	]);
+	const controllers = graphics.status === "fulfilled" ? graphics.value.controllers : [];
+	const highest = (key: "utilizationGpu" | "temperatureGpu", max: number) => {
+		const values = controllers
+			.map((controller) => reading(controller[key], max))
+			.filter((value): value is number => value !== undefined);
+		return values.length ? Math.max(...values) : undefined;
+	};
+	const gpu = highest("utilizationGpu", 100);
+	const gpuTemp = highest("temperatureGpu", 150);
+	const amd =
+		process.platform === "linux" && (gpu === undefined || gpuTemp === undefined)
+			? await readAmdStats()
+			: {};
 	return {
-		times,
-		stats: {
-			cpu: prev ? cpuPercent(prev, times) : undefined,
-			ram: total > 0 ? clampPct(((total - freemem()) / total) * 100) : undefined,
-			gpu: linux ? readGpuBusy(sys) : undefined,
-			temp: linux ? readCpuTemp(sys) : undefined,
-		},
+		cpu: cpu.status === "fulfilled" ? reading(cpu.value.currentLoad, 100) : undefined,
+		cpuTemp: temperature.status === "fulfilled" ? reading(temperature.value.main, 150) : undefined,
+		gpu: gpu ?? amd.gpu,
+		gpuTemp: gpuTemp ?? amd.gpuTemp,
+		ram:
+			memory.status === "fulfilled" && memory.value.total > 0
+				? reading(((memory.value.total - memory.value.available) / memory.value.total) * 100, 100)
+				: undefined,
 	};
 }