@@ -534,6 +544,67 @@
// Initialize on load
updateAuthUI();
+ // Transport-bar session uptime ticker — time since page load.
+ (function() {
+ const pageLoadedAt = Date.now();
+ const el = document.getElementById('transport-uptime');
+ if (!el) return;
+ function pad(n) { return n < 10 ? '0' + n : String(n); }
+ function render() {
+ const secs = Math.floor((Date.now() - pageLoadedAt) / 1000);
+ const h = Math.floor(secs / 3600);
+ const m = Math.floor((secs % 3600) / 60);
+ const s = secs % 60;
+ el.textContent = `${pad(h)}:${pad(m)}:${pad(s)}`;
+ }
+ render();
+ setInterval(render, 1000);
+ })();
+
+ // Transport-bar poll-interval control — cycles through 1/2/5/10s
+ // presets on click. Affects dashboard refresh + perf polling, so
+ // it belongs in the global transport bar rather than the Dashboard
+ // toolbar.
+ (function() {
+ const PRESETS = [1000, 2000, 5000, 10000];
+ const KEY = 'dashboard_poll_interval';
+ const root = document.getElementById('transport-poll');
+ const valEl = document.getElementById('transport-poll-value');
+ if (!root || !valEl) return;
+
+ function render(ms) {
+ const s = Math.round(ms / 1000);
+ valEl.textContent = `${s}s`;
+ }
+
+ function apply(ms) {
+ localStorage.setItem(KEY, String(ms));
+ render(ms);
+ // Call the existing global hook if loaded (it also restarts
+ // auto-refresh + perf polling with the new interval).
+ if (typeof window.changeDashboardPollInterval === 'function') {
+ window.changeDashboardPollInterval(String(Math.round(ms / 1000)));
+ }
+ }
+
+ render(parseInt(localStorage.getItem(KEY), 10) || 2000);
+
+ function cycle(dir) {
+ const cur = parseInt(localStorage.getItem(KEY), 10) || 2000;
+ let idx = PRESETS.indexOf(cur);
+ if (idx < 0) idx = 1; // default to 2s if unknown
+ idx = (idx + (dir || 1) + PRESETS.length) % PRESETS.length;
+ apply(PRESETS[idx]);
+ }
+
+ root.addEventListener('click', function(e) { e.stopPropagation(); cycle(1); });
+ root.addEventListener('keydown', function(e) {
+ if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); cycle(1); }
+ else if (e.key === 'ArrowRight' || e.key === 'ArrowUp') { e.preventDefault(); cycle(1); }
+ else if (e.key === 'ArrowLeft' || e.key === 'ArrowDown') { e.preventDefault(); cycle(-1); }
+ });
+ })();
+
// Modal functions
function togglePasswordVisibility() {
const input = document.getElementById('api-key-input');
diff --git a/server/src/ledgrab/utils/metrics/psutil_provider.py b/server/src/ledgrab/utils/metrics/psutil_provider.py
index facaf52..7aa8980 100644
--- a/server/src/ledgrab/utils/metrics/psutil_provider.py
+++ b/server/src/ledgrab/utils/metrics/psutil_provider.py
@@ -3,6 +3,11 @@
from __future__ import annotations
import os
+import platform
+import subprocess
+import threading
+import time
+from typing import Optional
from .types import MemorySnapshot, ProcessSnapshot, ThermalSnapshot
@@ -24,6 +29,14 @@ class PsutilMetricsProvider:
self._process = psutil_module.Process(os.getpid())
self._process.cpu_percent(interval=None)
self._cpu_count = int(psutil_module.cpu_count(logical=True) or 1)
+ # psutil has no sensors_temperatures() on Windows, so fall back to a
+ # throttled WMI/LHM reader running in a daemon thread. Disabled in
+ # tests via LEDGRAB_DISABLE_WIN_TEMP.
+ self._windows_temp: Optional[_WindowsCpuTemp] = (
+ _WindowsCpuTemp()
+ if platform.system() == "Windows" and not os.environ.get("LEDGRAB_DISABLE_WIN_TEMP")
+ else None
+ )
def cpu_percent(self) -> float:
return float(self._psutil.cpu_percent(interval=None))
@@ -80,8 +93,137 @@ class PsutilMetricsProvider:
except Exception:
pass
+ # Windows fallback: psutil exposes no CPU temperature there, so the
+ # reading would always be None without this. Other platforms keep
+ # the psutil result as-is.
+ if cpu_temp is None and self._windows_temp is not None:
+ cpu_temp = self._windows_temp.get()
+
return ThermalSnapshot(
battery_percent=battery_pct,
battery_temp_c=battery_temp,
cpu_temp_c=cpu_temp,
)
+
+
+# ── Windows CPU temperature helper ───────────────────────────────────────
+
+# Windows has no user-space API for real per-core CPU temperature without
+# a vendor driver or third-party monitoring service, so we only try sources
+# that reflect the actual CPU die rather than a motherboard/chassis zone:
+#
+# 1. LibreHardwareMonitor / OpenHardwareMonitor WMI — °C. Only usable when
+# the monitoring app is running, but reads Intel DTS / AMD SMN directly
+# so the reading actually tracks load.
+# 2. ``MSAcpi_ThermalZoneTemperature`` WMI — Kelvin × 10. Some OEM boards
+# wire this to the CPU; many require admin or expose a chassis zone
+# instead. Only used as a last resort.
+#
+# The ``\Thermal Zone Information(*)\Temperature`` perf counter is
+# deliberately NOT queried: on most consumer desktops it returns ACPI
+# TZxx zones that are pinned at ~27–30 °C regardless of CPU load — a
+# misleading stable reading is worse than no reading at all.
+#
+# Emits a single numeric line on stdout and exits.
+_WIN_TEMP_POWERSHELL = (
+ "$ErrorActionPreference='SilentlyContinue';"
+ "foreach ($ns in 'root/LibreHardwareMonitor','root/OpenHardwareMonitor') {"
+ " $lhm = Get-CimInstance -Namespace $ns -ClassName Sensor"
+ " -Filter \"SensorType='Temperature'\";"
+ " if ($lhm) {"
+ " $cpu = $lhm | Where-Object { $_.Parent -match 'cpu' -or $_.Name -match 'CPU' }"
+ " | Sort-Object Value -Descending | Select-Object -First 1;"
+ " if ($cpu) { '{0:N2}' -f $cpu.Value; exit }"
+ " }"
+ "}"
+ "$acpi = Get-CimInstance -Namespace root/wmi -ClassName MSAcpi_ThermalZoneTemperature;"
+ "if ($acpi) {"
+ " $t = ($acpi | Measure-Object -Property CurrentTemperature -Maximum).Maximum;"
+ " if ($t) { '{0:N2}' -f ($t / 10.0 - 273.15); exit }"
+ "}"
+)
+
+
+def _query_windows_cpu_temp() -> Optional[float]:
+ """Run the PowerShell WMI probe once and parse the single-line result.
+
+ Returns None on any failure. Rejects wildly out-of-range values to
+ guard against sensors that report raw (un-scaled) Kelvin or 0.
+ """
+ if platform.system() != "Windows":
+ return None
+ try:
+ creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+ result = subprocess.run(
+ ["powershell", "-NoProfile", "-NonInteractive", "-Command", _WIN_TEMP_POWERSHELL],
+ capture_output=True,
+ text=True,
+ timeout=4.0,
+ creationflags=creationflags,
+ )
+ except (OSError, subprocess.TimeoutExpired):
+ return None
+ if result.returncode != 0:
+ return None
+ line = (result.stdout or "").strip().splitlines()
+ if not line:
+ return None
+ try:
+ # Locale may use comma as decimal separator (e.g. ru-RU).
+ temp = float(line[0].replace(",", ".").strip())
+ except ValueError:
+ return None
+ if -20.0 <= temp <= 150.0:
+ return temp
+ return None
+
+
+class _WindowsCpuTemp:
+ """Throttled background reader for Windows CPU temperature.
+
+ Spawning PowerShell costs hundreds of ms per call, so we refresh in a
+ daemon thread at most once every ``REFRESH_INTERVAL_S`` seconds and
+ return the most recent cached value from ``get()``. After
+ ``MAX_FAILURES`` consecutive empty results we self-disable to avoid
+ launching PowerShell forever on hosts without any usable sensor.
+ """
+
+ REFRESH_INTERVAL_S = 5.0
+ MAX_FAILURES = 3
+
+ def __init__(self) -> None:
+ self._cached_c: Optional[float] = None
+ self._last_refresh: float = 0.0
+ self._refreshing: bool = False
+ self._disabled: bool = False
+ self._failures: int = 0
+ self._lock = threading.Lock()
+
+ def get(self) -> Optional[float]:
+ if self._disabled:
+ return None
+ now = time.monotonic()
+ with self._lock:
+ due = now - self._last_refresh >= self.REFRESH_INTERVAL_S
+ should_start = due and not self._refreshing
+ if should_start:
+ self._refreshing = True
+ if should_start:
+ threading.Thread(target=self._refresh, daemon=True).start()
+ return self._cached_c
+
+ def _refresh(self) -> None:
+ try:
+ value = _query_windows_cpu_temp()
+ finally:
+ now = time.monotonic()
+ with self._lock:
+ self._last_refresh = now
+ self._refreshing = False
+ if value is not None:
+ self._cached_c = value
+ self._failures = 0
+ else:
+ self._failures += 1
+ if self._failures >= self.MAX_FAILURES:
+ self._disabled = True
diff --git a/server/tests/test_metrics_provider.py b/server/tests/test_metrics_provider.py
index bb9e25e..62d52d8 100644
--- a/server/tests/test_metrics_provider.py
+++ b/server/tests/test_metrics_provider.py
@@ -21,7 +21,10 @@ from ledgrab.utils.metrics import android_provider as android_mod
@pytest.fixture(autouse=True)
-def _reset_provider_cache():
+def _reset_provider_cache(monkeypatch):
+ # Disable the Windows CPU-temp background reader so tests don't spawn
+ # PowerShell when run on a Windows host.
+ monkeypatch.setenv("LEDGRAB_DISABLE_WIN_TEMP", "1")
reset_metrics_provider()
yield
reset_metrics_provider()