fix(cpu): add WSL temperature fallback

Author: DennySORA

src/collectors/cpu.rs

@@ -1,4 +1,6 @@
 use std::fs;
+use std::path::Path;
+use std::process::Command;
 use std::time::Instant;
 
 use crate::domain::cpu::{CoreStats, CpuStats, CpuTimeSample};
@@ -11,6 +13,9 @@ pub struct CpuCollector {
     prev_total: Option<CpuTimeSample>,
     prev_cores: Vec<CpuTimeSample>,
     prev_time: Instant,
+    is_wsl: bool,
+    last_wsl_temp_check: Option<Instant>,
+    cached_wsl_temp: Option<f64>,
 }
 
 impl Default for CpuCollector {
@@ -25,6 +30,9 @@ impl CpuCollector {
             prev_total: None,
             prev_cores: Vec::new(),
             prev_time: Instant::now(),
+            is_wsl: Self::detect_wsl(),
+            last_wsl_temp_check: None,
+            cached_wsl_temp: None,
         }
     }
 
@@ -112,32 +120,209 @@ impl CpuCollector {
         None
     }
 
-    fn read_cpu_temperature() -> Option<f64> {
-        // Try common thermal zone paths
-        for i in 0..20 {
-            let type_path = format!("/sys/class/thermal/thermal_zone{i}/type");
-            let temp_path = format!("/sys/class/thermal/thermal_zone{i}/temp");
-
-            if let Ok(zone_type) = fs::read_to_string(&type_path) {
-                let zone_type = zone_type.trim().to_lowercase();
-                // Look for CPU-related thermal zones
-                if (zone_type.contains("cpu")
-                    || zone_type.contains("x86_pkg")
-                    || zone_type.contains("coretemp")
-                    || zone_type.contains("soc"))
-                    && let Ok(temp_str) = fs::read_to_string(&temp_path)
-                    && let Ok(millideg) = temp_str.trim().parse::<f64>()
-                {
-                    return Some(millideg / 1000.0);
+    fn normalize_temperature(raw: f64) -> Option<f64> {
+        let normalized = if raw.abs() > 250.0 { raw / 1000.0 } else { raw };
+        if (-40.0..=150.0).contains(&normalized) {
+            Some(normalized)
+        } else {
+            None
+        }
+    }
+
+    fn cpu_temp_match_score(name: Option<&str>, label: Option<&str>) -> u8 {
+        let mut score = 0;
+
+        let update_score = |text: &str, score: &mut u8| {
+            if text.contains("package") || text.contains("x86_pkg") {
+                *score = (*score).max(100);
+            } else if text.contains("tdie") || text.contains("tctl") {
+                *score = (*score).max(95);
+            } else if text.contains("cpu") || text.contains("core") || text.contains("ccd") {
+                *score = (*score).max(85);
+            } else if text.contains("soc") {
+                *score = (*score).max(70);
+            } else if text.contains("coretemp")
+                || text.contains("k10temp")
+                || text.contains("zenpower")
+                || text.contains("cpu_thermal")
+                || text.contains("cpu-thermal")
+            {
+                *score = (*score).max(60);
+            }
+        };
+
+        if let Some(name) = name {
+            update_score(name, &mut score);
+        }
+        if let Some(label) = label {
+            update_score(label, &mut score);
+        }
+
+        score
+    }
+
+    fn pick_best_temperature(candidates: impl IntoIterator<Item = (u8, f64)>) -> Option<f64> {
+        let mut best_match: Option<(u8, f64)> = None;
+        let mut fallback: Option<f64> = None;
+
+        for (score, temp) in candidates {
+            if score > 0 {
+                match best_match {
+                    Some((best_score, best_temp))
+                        if score < best_score || (score == best_score && temp <= best_temp) => {}
+                    _ => best_match = Some((score, temp)),
+                }
+            } else {
+                fallback = Some(match fallback {
+                    Some(best_temp) => best_temp.max(temp),
+                    None => temp,
+                });
+            }
+        }
+
+        best_match.map(|(_, temp)| temp).or(fallback)
+    }
+
+    fn read_cpu_temperature_from_hwmon_root(root: &Path) -> Option<f64> {
+        let mut candidates = Vec::new();
+
+        for entry in fs::read_dir(root).ok()?.flatten() {
+            let hwmon_path = entry.path();
+            if !hwmon_path.is_dir() {
+                continue;
+            }
+
+            let sensor_name = fs::read_to_string(hwmon_path.join("name"))
+                .ok()
+                .map(|s| s.trim().to_lowercase());
+
+            let Ok(files) = fs::read_dir(&hwmon_path) else {
+                continue;
+            };
+
+            for file in files.flatten() {
+                let file_name = file.file_name();
+                let file_name = file_name.to_string_lossy();
+
+                let Some(sensor_prefix) = file_name.strip_suffix("_input") else {
+                    continue;
+                };
+                if !sensor_prefix.starts_with("temp") {
+                    continue;
                 }
+
+                let Some(temp) = fs::read_to_string(file.path())
+                    .ok()
+                    .and_then(|s| s.trim().parse::<f64>().ok())
+                    .and_then(Self::normalize_temperature)
+                else {
+                    continue;
+                };
+
+                let label = fs::read_to_string(hwmon_path.join(format!("{sensor_prefix}_label")))
+                    .ok()
+                    .map(|s| s.trim().to_lowercase());
+                let score = Self::cpu_temp_match_score(sensor_name.as_deref(), label.as_deref());
+                candidates.push((score, temp));
+            }
+        }
+
+        Self::pick_best_temperature(candidates)
+    }
+
+    fn read_cpu_temperature_from_thermal_root(root: &Path) -> Option<f64> {
+        let mut candidates = Vec::new();
+
+        for entry in fs::read_dir(root).ok()?.flatten() {
+            let zone_path = entry.path();
+            if !zone_path.is_dir() {
+                continue;
             }
+
+            let zone_type = fs::read_to_string(zone_path.join("type"))
+                .ok()
+                .map(|s| s.trim().to_lowercase());
+            let Some(temp) = fs::read_to_string(zone_path.join("temp"))
+                .ok()
+                .and_then(|s| s.trim().parse::<f64>().ok())
+                .and_then(Self::normalize_temperature)
+            else {
+                continue;
+            };
+
+            let score = Self::cpu_temp_match_score(zone_type.as_deref(), None);
+            candidates.push((score, temp));
         }
 
-        // Fallback: use first thermal zone
-        fs::read_to_string("/sys/class/thermal/thermal_zone0/temp")
+        Self::pick_best_temperature(candidates)
+    }
+
+    fn detect_wsl() -> bool {
+        if std::env::var_os("WSL_DISTRO_NAME").is_some() {
+            return true;
+        }
+
+        fs::read_to_string("/proc/sys/kernel/osrelease")
             .ok()
-            .and_then(|s| s.trim().parse::<f64>().ok())
-            .map(|millideg| millideg / 1000.0)
+            .map(|s| s.to_ascii_lowercase().contains("microsoft"))
+            .unwrap_or(false)
+            || fs::read_to_string("/proc/version")
+                .ok()
+                .map(|s| s.to_ascii_lowercase().contains("microsoft"))
+                .unwrap_or(false)
+    }
+
+    fn read_wsl_temperature_via_powershell() -> Option<f64> {
+        let script = concat!(
+            "$temps = Get-CimInstance -ClassName ",
+            "Win32_PerfFormattedData_Counters_ThermalZoneInformation ",
+            "| ForEach-Object { [math]::Round($_.Temperature - 273.15, 1) }; ",
+            "if ($temps) { ($temps | Measure-Object -Maximum).Maximum }"
+        );
+
+        let output = Command::new("powershell.exe")
+            .args(["-NoProfile", "-Command", script])
+            .output()
+            .ok()?;
+
+        if !output.status.success() {
+            return None;
+        }
+
+        String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .parse::<f64>()
+            .ok()
+            .and_then(Self::normalize_temperature)
+    }
+
+    fn read_wsl_temperature_cached(&mut self) -> Option<f64> {
+        const WSL_TEMP_CACHE_SECS: u64 = 3;
+
+        if let Some(last) = self.last_wsl_temp_check
+            && last.elapsed().as_secs() < WSL_TEMP_CACHE_SECS
+        {
+            return self.cached_wsl_temp;
+        }
+
+        let temp = Self::read_wsl_temperature_via_powershell();
+        self.cached_wsl_temp = temp;
+        self.last_wsl_temp_check = Some(Instant::now());
+        temp
+    }
+
+    fn read_cpu_temperature(&mut self) -> Option<f64> {
+        Self::read_cpu_temperature_from_hwmon_root(Path::new("/sys/class/hwmon"))
+            .or_else(|| {
+                Self::read_cpu_temperature_from_thermal_root(Path::new("/sys/class/thermal"))
+            })
+            .or_else(|| {
+                if self.is_wsl {
+                    self.read_wsl_temperature_cached()
+                } else {
+                    None
+                }
+            })
     }
 
     /// Parse /proc/loadavg: "0.50 0.60 0.70 3/500 12345"
@@ -185,6 +370,102 @@ impl CpuCollector {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use std::path::{Path, PathBuf};
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    use super::CpuCollector;
+
+    fn make_temp_dir(name: &str) -> PathBuf {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("clock drift")
+            .as_nanos();
+        let dir =
+            std::env::temp_dir().join(format!("dgxtop-{name}-{}-{unique}", std::process::id()));
+        std::fs::create_dir_all(&dir).expect("failed to create temp dir");
+        dir
+    }
+
+    fn write_file(path: &Path, contents: &str) {
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).expect("failed to create parent dir");
+        }
+        std::fs::write(path, contents).expect("failed to write test file");
+    }
+
+    fn assert_temp_eq(actual: Option<f64>, expected: f64) {
+        let actual = actual.expect("expected a temperature");
+        assert!(
+            (actual - expected).abs() < f64::EPSILON,
+            "expected {expected}, got {actual}"
+        );
+    }
+
+    #[test]
+    fn hwmon_prefers_cpu_package_sensor() {
+        let root = make_temp_dir("cpu-hwmon-package");
+
+        write_file(&root.join("hwmon0/name"), "nvme\n");
+        write_file(&root.join("hwmon0/temp1_input"), "42000\n");
+
+        write_file(&root.join("hwmon1/name"), "coretemp\n");
+        write_file(&root.join("hwmon1/temp1_input"), "63500\n");
+        write_file(&root.join("hwmon1/temp1_label"), "Package id 0\n");
+
+        assert_temp_eq(
+            CpuCollector::read_cpu_temperature_from_hwmon_root(&root),
+            63.5,
+        );
+
+        std::fs::remove_dir_all(root).expect("failed to clean temp dir");
+    }
+
+    #[test]
+    fn hwmon_accepts_unlabelled_cpu_sensor_names() {
+        let root = make_temp_dir("cpu-hwmon-unlabelled");
+
+        write_file(&root.join("hwmon0/name"), "k10temp\n");
+        write_file(&root.join("hwmon0/temp1_input"), "58750\n");
+
+        assert_temp_eq(
+            CpuCollector::read_cpu_temperature_from_hwmon_root(&root),
+            58.75,
+        );
+
+        std::fs::remove_dir_all(root).expect("failed to clean temp dir");
+    }
+
+    #[test]
+    fn thermal_zone_fallback_prefers_cpu_like_types() {
+        let root = make_temp_dir("cpu-thermal-zone");
+
+        write_file(&root.join("thermal_zone0/type"), "acpitz\n");
+        write_file(&root.join("thermal_zone0/temp"), "27000\n");
+
+        write_file(&root.join("thermal_zone1/type"), "x86_pkg_temp\n");
+        write_file(&root.join("thermal_zone1/temp"), "68000\n");
+
+        assert_temp_eq(
+            CpuCollector::read_cpu_temperature_from_thermal_root(&root),
+            68.0,
+        );
+
+        std::fs::remove_dir_all(root).expect("failed to clean temp dir");
+    }
+
+    #[test]
+    fn normalize_temperature_accepts_millidegree_values() {
+        assert_temp_eq(CpuCollector::normalize_temperature(63500.0), 63.5);
+    }
+
+    #[test]
+    fn normalize_temperature_rejects_unreasonable_values() {
+        assert!(CpuCollector::normalize_temperature(500000.0).is_none());
+    }
+}
+
 impl Collector for CpuCollector {
     type Output = CpuStats;
 
@@ -257,7 +538,7 @@ impl Collector for CpuCollector {
             idle_percent,
             frequency_mhz: avg_freq,
             frequency_max_mhz: Self::read_max_frequency().unwrap_or(0.0),
-            temperature_celsius: Self::read_cpu_temperature(),
+            temperature_celsius: self.read_cpu_temperature(),
             core_count,
             cores: per_core_stats,
             load_avg_1m,

src/ui/views/overview.rs

@@ -323,6 +323,7 @@ fn render_cpu_info_line(
                 .add_modifier(Modifier::BOLD),
         ),
         Span::styled("  ", Style::default()),
+        Span::styled("temp ", Style::default().fg(theme.text_muted)),
         Span::styled(format!(" {temp_str}"), Style::default().fg(temp_color)),
         Span::styled("  ", Style::default()),
         Span::styled(format!(" {freq_str}"), Style::default().fg(theme.text_dim)),