@camstack/system 1.2.417 → 1.2.418

package/dist/builtins/platform-probe/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BMOD9OyH.js");
+const require_dist = require("../../dist-DVUg8e1T.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -59,7 +59,257 @@ function classifyCoralAccelerator(fsx) {
 	return null;
 }
 //#endregion
+//#region src/builtins/platform-probe/amd-npu.ts
+var amd_npu_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	classifyAmdNpu: () => classifyAmdNpu,
+	xdnaInfoForDevice: () => xdnaInfoForDevice
+});
+var ACCEL_CLASS = "/sys/class/accel";
+var ACCEL_DEV = "/dev/accel";
+var AMD_PCI_VENDOR = "0x1022";
+/** Phoenix / Hawk Point XDNA1. */
+var XDNA1_DEVICES = new Set(["0x1502"]);
+/** Strix / Krackan XDNA2. */
+var XDNA2_DEVICES = new Set(["0x17f0"]);
+function normalizePciId(raw) {
+	const t = raw.trim().toLowerCase();
+	if (t.startsWith("0x")) return t;
+	if (t.length > 0 && [...t].every((c) => "0123456789abcdef".includes(c))) return "0x" + t;
+	return t;
+}
+function hasAccelCharDevice(fsx) {
+	if (fsx.listDir(ACCEL_DEV).some((n) => n.startsWith("accel"))) return true;
+	return fsx.exists("/dev/accel/accel0");
+}
+/**
+* Detect an AMD XDNA NPU and report it as **present only**.
+*
+* Inference is NOT offered until P2 (Ryzen AI on Linux is Strix-first;
+* Phoenix is not a production path today). The probe still names the
+* generation so the UI and fleet census can show the hardware.
+*/
+function classifyAmdNpu(ctx, fsx) {
+	if (ctx.platform !== "linux" || ctx.arch !== "x64" || !ctx.amdPresent) return null;
+	if (!hasAccelCharDevice(fsx)) return null;
+	for (const name of fsx.listDir(ACCEL_CLASS)) {
+		if (!name.startsWith("accel")) continue;
+		const vendor = normalizePciId(fsx.readFile("/sys/class/accel/" + name + "/device/vendor"));
+		const device = normalizePciId(fsx.readFile("/sys/class/accel/" + name + "/device/device"));
+		if (vendor !== AMD_PCI_VENDOR) continue;
+		return xdnaInfoForDevice(device);
+	}
+	return null;
+}
+/**
+* The NPU descriptor for an AMD PCI device id (`0x1502` or `1502`). Shared by
+* the Linux sysfs probe and the Windows PnP probe so both name the same
+* silicon the same way.
+*/
+function xdnaInfoForDevice(rawDeviceId) {
+	const device = normalizePciId(rawDeviceId);
+	if (XDNA1_DEVICES.has(device)) return {
+		type: "amd-xdna",
+		name: "AMD XDNA1 NPU",
+		generation: "xdna1"
+	};
+	if (XDNA2_DEVICES.has(device)) return {
+		type: "amd-xdna",
+		name: "AMD XDNA2 NPU",
+		generation: "xdna2"
+	};
+	return {
+		type: "amd-xdna",
+		name: "AMD XDNA NPU"
+	};
+}
+//#endregion
+//#region src/builtins/platform-probe/windows-hardware.ts
+var PCI_VENDOR_NVIDIA = "10DE";
+var PCI_VENDOR_INTEL = "8086";
+/** Radeon graphics are 1002; the XDNA NPU is a 1022 device. */
+var PCI_VENDORS_AMD = new Set(["1002", "1022"]);
+/** Adapters that are not hardware: RDP, hypervisor, capture and spoofing drivers. */
+var VIRTUAL_ADAPTER = /basic display|basic render|remote display|hyper-v|vmware|virtualbox|parallels|citrix|parsec|indirect display|displaylink|mirror driver|virtual/i;
+/** One PowerShell process answers both: video controllers and AMD PCI devices. */
+var POWERSHELL_SCRIPT = [
+	"$ErrorActionPreference = 'SilentlyContinue'",
+	"$gpu = @(Get-CimInstance Win32_VideoController | Select-Object Name, PNPDeviceID)",
+	"$npu = @(Get-CimInstance Win32_PnPEntity | Where-Object { $_.PNPDeviceID -match 'VEN_1022&DEV_(1502|17F0)' } | Select-Object Name, PNPDeviceID)",
+	"@{ gpu = $gpu; npu = $npu } | ConvertTo-Json -Compress -Depth 3"
+].join("; ");
+function powershellInvocation(systemRoot) {
+	return [`${systemRoot ?? "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, [
+		"-NoProfile",
+		"-NonInteractive",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-Command",
+		POWERSHELL_SCRIPT
+	]];
+}
+var WMIC_VIDEO_ARGS = [
+	"path",
+	"Win32_VideoController",
+	"get",
+	"Name,PNPDeviceID",
+	"/format:csv"
+];
+var WMIC_AMD_PNP_ARGS = [
+	"path",
+	"Win32_PnPEntity",
+	"where",
+	"PNPDeviceID like 'PCI\\\\VEN_1022&DEV_%'",
+	"get",
+	"Name,PNPDeviceID",
+	"/format:csv"
+];
+function asRecordList(value) {
+	if (Array.isArray(value)) return value.filter((v) => v !== null && typeof v === "object" && !Array.isArray(v));
+	return value !== null && typeof value === "object" ? [Object.fromEntries(Object.entries(value))] : [];
+}
+function str(value) {
+	return typeof value === "string" ? value : "";
+}
+/** PowerShell prepends a BOM on some hosts, which `JSON.parse` rejects. */
+function parseJson(text) {
+	return JSON.parse(text.replace(/^\uFEFF/, "").trim());
+}
+/**
+* `{"gpu":[...],"npu":[...]}` as the script emits it. A single result comes
+* back as an object rather than a one-element array, and an empty one as
+* `null` — all three are handled.
+*/
+function parsePowershellOutput(text) {
+	const root = parseJson(text);
+	const gpu = root !== null && typeof root === "object" ? Reflect.get(root, "gpu") : void 0;
+	const npu = root !== null && typeof root === "object" ? Reflect.get(root, "npu") : void 0;
+	const toDevice = (r) => ({
+		name: str(r["Name"]),
+		pnpDeviceId: str(r["PNPDeviceID"])
+	});
+	return {
+		controllers: asRecordList(gpu).map(toDevice),
+		pnp: asRecordList(npu).map(toDevice)
+	};
+}
+/**
+* `wmic ... /format:csv` — a blank line, then `Node,<cols alphabetical>`, then
+* one row per object. The device name can contain commas, so only the FIRST
+* column boundaries are trusted: columns after `Node` are `Name,PNPDeviceID`
+* and the PNP id (no commas) is taken from the END of the row.
+*/
+function parseWmicCsv(text) {
+	const lines = text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+	const headerIndex = lines.findIndex((l) => /^node,/i.test(l));
+	if (headerIndex < 0) return [];
+	const out = [];
+	for (const line of lines.slice(headerIndex + 1)) {
+		const parts = line.split(",");
+		if (parts.length < 3) continue;
+		const pnpDeviceId = (parts[parts.length - 1] ?? "").trim();
+		const name = parts.slice(1, -1).join(",").trim();
+		if (pnpDeviceId.length > 0) out.push({
+			name,
+			pnpDeviceId
+		});
+	}
+	return out;
+}
+/** The PCI vendor id (`10DE`) out of a PnP id like `PCI\VEN_10DE&DEV_2504&...`. */
+function pciVendorOf(pnpDeviceId) {
+	const m = /VEN_([0-9A-F]{4})/i.exec(pnpDeviceId);
+	return m?.[1] ? m[1].toUpperCase() : null;
+}
+function pciDeviceOf(pnpDeviceId) {
+	const m = /DEV_([0-9A-F]{4})/i.exec(pnpDeviceId);
+	return m?.[1] ? m[1].toLowerCase() : null;
+}
+function gpuVendor(c) {
+	const vendor = pciVendorOf(c.pnpDeviceId);
+	if (vendor === PCI_VENDOR_NVIDIA) return "nvidia";
+	if (vendor === PCI_VENDOR_INTEL) return "intel";
+	if (vendor !== null && PCI_VENDORS_AMD.has(vendor)) return "amd";
+	if (/nvidia|geforce|quadro|rtx/i.test(c.name)) return "nvidia";
+	if (/intel/i.test(c.name)) return "intel";
+	if (/amd|radeon/i.test(c.name)) return "amd";
+	return null;
+}
+/**
+* The accelerator the node should treat as its GPU. Same preference as the
+* Linux probe — NVIDIA, then Intel, then AMD — so a laptop with an Intel iGPU
+* and a discrete card is described the way the rest of the system already
+* expects. Virtual adapters never count.
+*/
+function classifyWindowsGpu(controllers) {
+	const real = controllers.filter((c) => c.name.length > 0 && !VIRTUAL_ADAPTER.test(c.name));
+	for (const wanted of [
+		"nvidia",
+		"intel",
+		"amd"
+	]) {
+		const hit = real.find((c) => gpuVendor(c) === wanted);
+		if (hit) return {
+			type: wanted,
+			name: hit.name
+		};
+	}
+	return null;
+}
+/**
+* An AMD XDNA NPU from PnP ids: `PCI\VEN_1022&DEV_1502` (Phoenix / Hawk Point)
+* or `DEV_17F0` (Strix / Krackan). Present-only, exactly like the Linux probe.
+*/
+function classifyWindowsAmdNpu(devices) {
+	for (const d of devices) {
+		if (pciVendorOf(d.pnpDeviceId) !== "1022") continue;
+		const device = pciDeviceOf(d.pnpDeviceId);
+		if (device === "1502" || device === "17f0") return xdnaInfoForDevice(device);
+	}
+	return null;
+}
+async function viaPowershell(run, systemRoot) {
+	const [file, args] = powershellInvocation(systemRoot);
+	const parsed = parsePowershellOutput(await run(file, args));
+	return {
+		gpu: classifyWindowsGpu(parsed.controllers),
+		npu: classifyWindowsAmdNpu(parsed.pnp),
+		source: "powershell"
+	};
+}
+async function viaWmic(run) {
+	const [video, amd] = await Promise.all([run("wmic", WMIC_VIDEO_ARGS), run("wmic", WMIC_AMD_PNP_ARGS).catch(() => "")]);
+	return {
+		gpu: classifyWindowsGpu(parseWmicCsv(video)),
+		npu: classifyWindowsAmdNpu(parseWmicCsv(amd)),
+		source: "wmic"
+	};
+}
+/**
+* GPU + AMD NPU on a Windows host. NEVER throws: a probe that cannot run is
+* `{ gpu: null, npu: null, source: 'none' }` and boot goes on — the node then
+* scores as a CPU node, which is correct for hardware we could not see.
+*/
+async function probeWindowsHardware(run, options = {}) {
+	try {
+		return await viaPowershell(run, options.systemRoot);
+	} catch (powershellError) {
+		options.onFallback?.(`PowerShell probe failed (${powershellError instanceof Error ? powershellError.message : String(powershellError)}); trying wmic`);
+	}
+	try {
+		return await viaWmic(run);
+	} catch (wmicError) {
+		options.onFallback?.(`wmic probe failed (${wmicError instanceof Error ? wmicError.message : String(wmicError)}); hardware unknown`);
+		return {
+			gpu: null,
+			npu: null,
+			source: "none"
+		};
+	}
+}
+//#endregion
 //#region src/builtins/platform-probe/platform-scorer.ts
+/** WMI can be slow on a cold machine, but never worth stalling boot for. */
+var WINDOWS_PROBE_TIMEOUT_MS = 15e3;
 /**
 * Promisified `execFile`. Used across the scorer so every subprocess
 * spawn yields the event loop — critical at boot because a single sync
@@ -237,24 +487,25 @@ var PlatformScorer = class {
 			};
 			npu = { type: "apple-ane" };
 		}
+		if (platform === "win32") {
+			const nvidia = await this.probeNvidiaSmi();
+			const win = await this.probeWindowsHardwareSafely();
+			gpu = nvidia ?? win.gpu;
+			npu = win.npu;
+			if (gpu) this.logger.info("Windows GPU detected", { meta: {
+				type: gpu.type,
+				name: gpu.name
+			} });
+			if (npu && win.source !== "none") this.logger.info("AMD XDNA NPU detected (present only)", { meta: {
+				type: npu.type,
+				name: npu.name,
+				generation: npu.generation,
+				source: win.source
+			} });
+		}
 		if (platform === "linux") {
-			try {
-				const { stdout } = await execFileAsync("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
-					encoding: "utf8",
-					timeout: 5e3
-				});
-				const output = stdout.trim();
-				if (output) {
-					const [name, mem] = output.split(",").map((s) => s.trim());
-					gpu = {
-						type: "nvidia",
-						name: name ?? "NVIDIA GPU",
-						memoryMB: parseInt(mem ?? "0")
-					};
-				}
-			} catch (err) {
-				this.logger.debug("NVIDIA GPU detection failed", { meta: { error: require_dist.errMsg(err) } });
-			}
+			const nvidia = await this.probeNvidiaSmi();
+			if (nvidia) gpu = nvidia;
 			const listRenderNodes = () => {
 				try {
 					return node_fs.readdirSync("/dev/dri").filter((n) => n.startsWith("renderD")).map((n) => `/dev/dri/${n}`);
@@ -313,7 +564,7 @@ var PlatformScorer = class {
 				} });
 			}
 			if (!npu) {
-				const { classifyAmdNpu } = await Promise.resolve().then(() => require("../../amd-npu-B-QyyMyF.js"));
+				const { classifyAmdNpu } = await Promise.resolve().then(() => amd_npu_exports);
 				npu = classifyAmdNpu({
 					platform,
 					arch,
@@ -348,6 +599,53 @@ var PlatformScorer = class {
 			coral
 		};
 	}
+	/** NVIDIA's own tool: exact model and VRAM. Null when absent or failing. */
+	async probeNvidiaSmi() {
+		try {
+			const { stdout } = await execFileAsync("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
+				encoding: "utf8",
+				timeout: 5e3,
+				windowsHide: true
+			});
+			const output = stdout.trim();
+			if (!output) return null;
+			const [name, mem] = output.split(",").map((s) => s.trim());
+			return {
+				type: "nvidia",
+				name: name ?? "NVIDIA GPU",
+				memoryMB: parseInt(mem ?? "0")
+			};
+		} catch (err) {
+			this.logger.debug("NVIDIA GPU detection failed", { meta: { error: require_dist.errMsg(err) } });
+			return null;
+		}
+	}
+	/** Windows WMI probe; bounded, and a failure is a log line, never a boot failure. */
+	async probeWindowsHardwareSafely() {
+		const run = async (file, args) => {
+			const { stdout } = await execFileAsync(file, [...args], {
+				encoding: "utf8",
+				timeout: WINDOWS_PROBE_TIMEOUT_MS,
+				windowsHide: true,
+				maxBuffer: 4 * 1024 * 1024
+			});
+			return stdout;
+		};
+		const systemRoot = process.env["SystemRoot"];
+		try {
+			return await probeWindowsHardware(run, {
+				...systemRoot === void 0 ? {} : { systemRoot },
+				onFallback: (reason) => this.logger.warn("Windows hardware probe degraded", { meta: { reason } })
+			});
+		} catch (err) {
+			this.logger.warn("Windows hardware probe failed — scoring as a CPU node", { meta: { error: require_dist.errMsg(err) } });
+			return {
+				gpu: null,
+				npu: null,
+				source: "none"
+			};
+		}
+	}
 	/**
 	* Locates a Python interpreter without importing any module.
 	*