level = logging.DEBUG if (debug or os.environ.get("SYSTEMCHECK_DEBUG")) else logging.WARNING

logging.basicConfig(

level=level,

format="%(name)s: %(levelname)s: %(message)s",

stream=sys.stderr,

try:

out = subprocess.check_output(

cmd,

input=input_text.encode() if input_text else None,

stderr=subprocess.DEVNULL,

timeout=timeout,

)

return out.decode(errors="replace")

except subprocess.TimeoutExpired:

_LOG.debug("Command timed out: %s", cmd)

return ""

except (subprocess.CalledProcessError, OSError, UnicodeDecodeError) as e:

_LOG.debug("Command failed: %s: %s", cmd, e)

cmd: List[str], timeout: Optional[int] = None

) -> str:

"""Run command and return stdout even when exit code is non-zero (e.g. du/find with permission denied)."""

try:

r = subprocess.run(

cmd,

stdout=subprocess.PIPE,

stderr=subprocess.DEVNULL,

timeout=timeout,

)

return r.stdout.decode(errors="replace") if r.stdout else ""

except subprocess.TimeoutExpired:

_LOG.debug("Command timed out: %s", cmd)

return ""

except (OSError, UnicodeDecodeError) as e:

_LOG.debug("Command failed: %s: %s", cmd, e)

if n is None:

return "N/A"

units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]

i = 0

x = float(n)

while x >= 1024 and i < len(units) - 1:

x /= 1024.0

i += 1

if not s:

return None

s = s.strip()

if s.lower() in ("unknown", "no module installed"):

return None

m = re.match(r"(?i)\s*([\d.]+)\s*(b|kb|mb|gb|tb|pb)\s*$", s)

if not m:

return None

val = float(m.group(1))

unit = m.group(2).lower()

factor = {"b":1,"kb":1024,"mb":1024**2,"gb":1024**3,"tb":1024**4,"pb":1024**5}[unit]

def __init__(self, enabled: bool):

self.enabled = enabled and sys.stdout.isatty()

def code(self, s: str) -> str:

return s if self.enabled else ""

@property

def R(self): return self.code("\033[31m") # red

@property

def G(self): return self.code("\033[32m") # green

@property

def Y(self): return self.code("\033[33m") # yellow

@property

def B(self): return self.code("\033[34m") # blue

@property

def M(self): return self.code("\033[35m") # magenta

@property

def C(self): return self.code("\033[36m") # cyan

@property

def W(self): return self.code("\033[37m") # white

@property

def BOLD(self): return self.code("\033[1m")

@property

def DIM(self): return self.code("\033[2m")

@property

c = color

if pct is None:

return f"Usage: {c.DIM}N/A{c.RESET}"

p = max(0.0, min(100.0, float(pct)))

filled = int(round((p / 100.0) * width))

empty = width - filled

col = c.G if p < 60 else (c.Y if p < 85 else c.R)

d: Dict[str, str] = {}

path = "/etc/os-release"

if not os.path.exists(path):

return d

with open(path, "r", encoding="utf-8", errors="ignore") as f:

for line in f:

line = line.strip()

if not line or line.startswith("#") or "=" not in line:

continue

k, v = line.split("=", 1)

v = v.strip().strip('"').strip("'")

d[k] = v

info: Dict[str, Any] = {

"name": None, "pretty_name": None, "version": None, "id": None, "id_like": None,

"kernel": None, "architecture": None,

}

osr = parse_os_release()

if osr:

info["pretty_name"] = osr.get("PRETTY_NAME")

info["name"] = osr.get("NAME")

info["version"] = osr.get("VERSION") or osr.get("VERSION_ID")

info["id"] = osr.get("ID")

info["id_like"] = osr.get("ID_LIKE")

if which("hostnamectl"):

txt = sh(["hostnamectl"], timeout=3)

if txt:

m = re.search(r"Operating System:\s*(.+)", txt)

if m and not info["pretty_name"]:

info["pretty_name"] = m.group(1).strip()

m = re.search(r"Kernel:\s*(.+)", txt)

if m:

info["kernel"] = m.group(1).strip()

m = re.search(r"Architecture:\s*(.+)", txt)

if m:

info["architecture"] = m.group(1).strip()

if which("lsb_release") and not info.get("pretty_name"):

out = sh(["lsb_release", "-a"], timeout=3)

if out:

desc = re.search(r"Description:\s*(.+)", out)

if desc:

info["pretty_name"] = desc.group(1).strip()

rel = re.search(r"Release:\s*(.+)", out)

if rel and not info["version"]:

info["version"] = rel.group(1).strip()

dist = re.search(r"Distributor ID:\s*(.+)", out)

if dist and not info["name"]:

info["name"] = dist.group(1).strip()

try:

u = os.uname()

if not info["kernel"]:

info["kernel"] = f"{u.sysname} {u.release}"

if not info["architecture"]:

info["architecture"] = u.machine

except OSError as e:

_LOG.debug("os.uname: %s", e)

path = f"/sys/devices/virtual/dmi/id/{name}"

try:

if os.path.exists(path):

with open(path, "r", encoding="utf-8", errors="ignore") as f:

val = f.read().strip()

return val if val and val != "None" else None

except OSError as e:

_LOG.debug("Cannot read DMI file %s: %s", path, e)

txt = sh(["dmidecode", "-t", typ], timeout=5) if which("dmidecode") else ""

if not txt:

return []

blocks = [b.strip() for b in re.split(r"\n\s*\n", txt) if "Information" in b or "Device" in b]

sys_vendor = read_dmi_file("sys_vendor")

product_name = read_dmi_file("product_name")

product_version = read_dmi_file("product_version")

product_serial = read_dmi_file("product_serial")

chassis_type = read_dmi_file("chassis_type")

chassis_vendor = read_dmi_file("chassis_vendor")

board_vendor = read_dmi_file("board_vendor")

board_name = read_dmi_file("board_name")

board_version = read_dmi_file("board_version")

board_serial = read_dmi_file("board_serial")

if not (sys_vendor and product_name):

for b in parse_dmidecode_sections("system"):

if not sys_vendor:

m = re.search(r"Manufacturer:\s*(.+)", b)

if m: sys_vendor = m.group(1).strip()

if not product_name:

m = re.search(r"Product Name:\s*(.+)", b)

if m: product_name = m.group(1).strip()

if not product_version:

m = re.search(r"Version:\s*(.+)", b)

if m: product_version = m.group(1).strip()

if not product_serial:

m = re.search(r"Serial Number:\s*(.+)", b)

if m: product_serial = m.group(1).strip()

if not (board_vendor and board_name):

for b in parse_dmidecode_sections("baseboard"):

if not board_vendor:

m = re.search(r"Manufacturer:\s*(.+)", b)

if m: board_vendor = m.group(1).strip()

if not board_name:

m = re.search(r"Product Name:\s*(.+)", b)

if m: board_name = m.group(1).strip()

if not board_version:

m = re.search(r"Version:\s*(.+)", b)

if m: board_version = m.group(1).strip()

if not board_serial:

m = re.search(r"Serial Number:\s*(.+)", b)

if m: board_serial = m.group(1).strip()

if which("lshw") and (not sys_vendor or not product_name):

out = sh(["lshw", "-class", "system", "-json"], timeout=5)

try:

data = json.loads(out) if out else None

except json.JSONDecodeError as e:

_LOG.debug("lshw JSON parse failed: %s", e)

data = None

if isinstance(data, dict):

sys_vendor = sys_vendor or data.get("vendor")

product_name = product_name or data.get("product")

product_version = product_version or data.get("version")

product_serial = product_serial or data.get("serial")

return {

"vendor": sys_vendor,

"product_name": product_name,

"product_version": product_version,

"serial": product_serial,

"chassis_vendor": chassis_vendor,

"chassis_type": chassis_type,

"motherboard": {

"vendor": board_vendor,

"name": board_name,

"version": board_version,

"serial": board_serial,

},

info: Dict[str, Any] = {

"model": None, "architecture": None, "vendor": None,

"logical_cores": None, "physical_cores": None,

"base_freq_hz": None, "max_freq_hz": None,

"current_utilization_percent": None,

}

if which("lscpu"):

out = sh(["lscpu", "-J"])

if out:

try:

data = json.loads(out)

kv = {i["field"].strip(":"): i["data"] for i in data.get("lscpu", [])}

info["model"] = kv.get("Model name") or kv.get("Model Name")

info["architecture"] = kv.get("Architecture")

info["vendor"] = kv.get("Vendor ID")

try:

info["logical_cores"] = int(kv.get("CPU(s)")) if kv.get("CPU(s)") else None

except (TypeError, ValueError):

pass

try:

sockets = int(kv.get("Socket(s)") or 1)

cores_per_socket = int(kv.get("Core(s) per socket") or 0)

info["physical_cores"] = sockets * cores_per_socket or None

except (TypeError, ValueError):

pass

def parse_freq(s: Optional[str]) -> Optional[int]:

if not s: return None

m = re.search(r"([\d.]+)\s*(MHz|GHz)", s)

if not m: return None

val = float(m.group(1))

return int(val * (1_000_000 if m.group(2) == "MHz" else 1_000_000_000))

info["base_freq_hz"] = parse_freq(kv.get("CPU MHz") or kv.get("CPU max MHz"))

info["max_freq_hz"] = parse_freq(kv.get("CPU max MHz"))

except (KeyError, TypeError, ValueError, json.JSONDecodeError) as e:

_LOG.debug("lscpu parse error: %s", e)

if (info["model"] is None) and os.path.exists("/proc/cpuinfo"):

try:

with open("/proc/cpuinfo", "r", encoding="utf-8", errors="ignore") as f:

txt = f.read()

m = re.search(r"^model name\s*:\s*(.+)$", txt, re.M)

v = re.search(r"^vendor_id\s*:\s*(.+)$", txt, re.M)

info["model"] = info["model"] or (m.group(1).strip() if m else None)

info["vendor"] = info["vendor"] or (v.group(1).strip() if v else None)

if info["logical_cores"] is None:

info["logical_cores"] = len(re.findall(r"^processor\s*:\s*\d+", txt, re.M))

except OSError as e:

_LOG.debug("Cannot read /proc/cpuinfo: %s", e)

if psutil:

try:

info["current_utilization_percent"] = psutil.cpu_percent(interval=0.5)

except (AttributeError, TypeError) as e:

_LOG.debug("psutil cpu_percent: %s", e)

try:

freq = psutil.cpu_freq()

if freq:

if not info["base_freq_hz"] and freq.min:

info["base_freq_hz"] = int(freq.min * 1_000_000)

if not info["max_freq_hz"] and freq.max:

info["max_freq_hz"] = int(freq.max * 1_000_000)

except (AttributeError, TypeError) as e:

_LOG.debug("psutil cpu_freq: %s", e)

try:

if info["physical_cores"] is None:

info["physical_cores"] = psutil.cpu_count(logical=False)

if info["logical_cores"] is None:

info["logical_cores"] = psutil.cpu_count(logical=True)

except (AttributeError, TypeError) as e:

_LOG.debug("psutil cpu_count: %s", e)

info: Dict[str, Any] = {

"total_bytes": None, "available_bytes": None, "used_bytes": None, "free_bytes": None,

"usage_percent": None, "swap_total_bytes": None, "swap_used_bytes": None,

"swap_free_bytes": None, "swap_usage_percent": None,

}

if psutil:

try:

vm = psutil.virtual_memory()

info.update(dict(

total_bytes=int(vm.total), available_bytes=int(vm.available),

used_bytes=int(vm.used), free_bytes=int(vm.free), usage_percent=float(vm.percent)

))

except (AttributeError, TypeError, ValueError) as e:

_LOG.debug("psutil virtual_memory: %s", e)

try:

sm = psutil.swap_memory()

info.update(dict(

swap_total_bytes=int(sm.total), swap_used_bytes=int(sm.used),

swap_free_bytes=int(sm.free), swap_usage_percent=float(sm.percent)

))

except (AttributeError, TypeError, ValueError) as e:

_LOG.debug("psutil swap_memory: %s", e)

if info["total_bytes"] is None and os.path.exists("/proc/meminfo"):

kv: Dict[str, int] = {}

try:

with open("/proc/meminfo", "r", encoding="utf-8", errors="ignore") as f:

for line in f:

parts = line.split(":")

if len(parts) != 2:

continue

m = re.search(r"(\d+)\s*kB", parts[1])

if m:

kv[parts[0].strip()] = int(m.group(1)) * 1024

except OSError as e:

_LOG.debug("Cannot read /proc/meminfo: %s", e)

return info

total = kv.get("MemTotal")

avail = kv.get("MemAvailable", kv.get("MemFree"))

used = total - avail if total and avail else None

pct = (used / total * 100.0) if used and total else None

info.update(dict(

total_bytes=total, available_bytes=avail, used_bytes=used, free_bytes=kv.get("MemFree"),

usage_percent=pct, swap_total_bytes=kv.get("SwapTotal"), swap_free_bytes=kv.get("SwapFree"),

swap_used_bytes=(kv.get("SwapTotal", 0)-kv.get("SwapFree", 0)) if kv.get("SwapTotal") else None,

swap_usage_percent=((kv.get("SwapTotal", 0)-kv.get("SwapFree", 0))/kv.get("SwapTotal")*100.0)

if kv.get("SwapTotal") else None

))

gpus: List[Dict[str, Any]] = []

if not which("nvidia-smi"):

return gpus

# Use list form to avoid shell injection; nvidia-smi is in PATH

out = sh(

["nvidia-smi", "--query-gpu=name,driver_version,memory.total,memory.used,memory.free,pci.bus_id", "--format=csv,noheader,nounits"],

timeout=4,

)

for line in out.splitlines():

parts = [p.strip() for p in line.split(",")]

if len(parts) < 6:

continue

name, driver, mem_total, mem_used, mem_free, bus = parts[:6]

def mib_to_bytes(x: str) -> Optional[int]:

try:

return int(float(x)) * 1024 * 1024

except (ValueError, TypeError):

return None

total_b = mib_to_bytes(mem_total)

used_b = mib_to_bytes(mem_used)

free_b = mib_to_bytes(mem_free)

pct = None

if total_b and used_b is not None:

try:

pct = used_b / total_b * 100.0

except (ZeroDivisionError, TypeError):

pct = None

gpus.append({

"vendor": "NVIDIA",

"model": name or None,

"driver": driver or None,

"bus": bus or None,

"vram_total_bytes": total_b,

"vram_used_bytes": used_b,

"vram_free_bytes": free_b,

"vram_usage_percent": pct,

"source": "nvidia-smi",

})

if not which("lshw"):

return []

out = sh(["lshw", "-class", "display", "-json"], timeout=6)

gpus: List[Dict[str, Any]] = []

try:

data = json.loads(out) if out else None

except json.JSONDecodeError as e:

_LOG.debug("lshw display JSON parse failed: %s", e)

data = None

def walk(n):

if isinstance(n, dict):

yield n

for ch in n.get("children", []) or []:

yield from walk(ch)

elif isinstance(n, list):

for it in n:

yield from walk(it)

if data:

for node in walk(data):

if not isinstance(node, dict): continue

if node.get("class") != "display": continue

prod = node.get("product") or node.get("description")

vend = node.get("vendor")

drv = None

conf = node.get("configuration") or {}

if isinstance(conf, dict):

drv = conf.get("driver") or conf.get("driverversion")

size_b = node.get("size")

gpus.append({

"vendor": vend,

"model": prod,

"driver": drv,

"bus": node.get("businfo"),

"vram_total_bytes": int(size_b) if isinstance(size_b, int) else None,

"vram_used_bytes": None,

"vram_free_bytes": None,

"vram_usage_percent": None,

"source": "lshw",

})

if not which("lspci"):

return []

# Run lspci and filter in Python to avoid shell

out = sh(["lspci", "-mm", "-nn"], timeout=4)

gpus: List[Dict[str, Any]] = []

display_keywords = ("vga", "3d", "display")

for line in out.splitlines():

line_lower = line.lower()

if not any(kw in line_lower for kw in display_keywords):

continue

m = re.search(r'^\S+\s+"[^"]+"\s+"([^"]+)"\s+"([^"]+)"', line)

vend = prod = None

if m:

vend = m.group(1)

prod = m.group(2)

else:

parts = line.split(": ", 1)

if len(parts) == 2:

prod = parts[1]

gpus.append({

"vendor": vend,

"model": prod,

"driver": None,

"bus": None,

"vram_total_bytes": None,

"vram_used_bytes": None,

"vram_free_bytes": None,

"vram_usage_percent": None,

"source": "lspci",

})

gpus = parse_nvidia_smi()

if not gpus:

gpus = parse_lshw_display()

if not gpus:

gpus = parse_lspci_display()

name = (entry.get("name") or "").lower()

tran = (entry.get("transport") or "").lower()

rota = entry.get("rota")

typ = (entry.get("type") or "").lower()

if name.startswith("nvme") or tran == "nvme":

return "NVMe SSD"

if typ == "rom":

return "Optical"

if rota == 0:

return "SSD"

if rota == 1:

return "HDD"

if not which("lsblk"):

return {}

out = sh(["lsblk", "-J", "-O"])

try:

return json.loads(out) if out else {}

except json.JSONDecodeError as e:

_LOG.debug("lsblk JSON parse failed: %s", e)

devices: List[Dict[str, Any]] = []

for b in lsblk_json.get("blockdevices", []) or []:

if b.get("type") != "disk":

continue

dev = {

"name": b.get("name"),

"type": b.get("type"),

"model": b.get("model"),

"serial": b.get("serial"),

"vendor": b.get("vendor"),

"transport": b.get("tran"),

"rota": b.get("rota"),

"logical_block_size": b.get("log-sec") or b.get("LOG-SEC"),

"physical_block_size": b.get("phy-sec") or b.get("PHY-SEC"),

"size_bytes": b.get("size") if isinstance(b.get("size"), int) else None,

"children": [],

}

for c in b.get("children", []) or []:

dev["children"].append({

"name": c.get("name"),

"type": c.get("type"),

"fstype": c.get("fstype"),

"mountpoint": c.get("mountpoint"),

"size_bytes": c.get("size") if isinstance(c.get("size"), int) else None,

})

dev["class"] = classify_disk(dev)

devices.append(dev)

mounts: List[Dict[str, Any]] = []

if psutil:

try:

for p in psutil.disk_partitions(all=False):

if p.fstype in ("tmpfs", "devtmpfs", "squashfs", "overlay"):

continue

try:

usage = psutil.disk_usage(p.mountpoint)

except (OSError, PermissionError) as e:

_LOG.debug("disk_usage %s: %s", p.mountpoint, e)

continue

mounts.append(dict(

mountpoint=p.mountpoint, device=p.device, fstype=p.fstype,

total_bytes=int(usage.total), used_bytes=int(usage.used),

free_bytes=int(usage.free), usage_percent=float(usage.percent)

))

except (AttributeError, OSError) as e:

_LOG.debug("psutil disk_partitions: %s", e)

if not mounts:

out = sh(["df", "-P", "-B1"])

for line in out.splitlines()[1:]:

parts = line.split()

if len(parts) < 6: continue

dev, total, used, avail, pct, mnt = parts[:6]

if dev.startswith("tmpfs") or dev.startswith("devtmpfs"):

continue

try:

mounts.append(dict(

mountpoint=mnt, device=dev, fstype=None,

total_bytes=int(total), used_bytes=int(used),

free_bytes=int(avail),

usage_percent=float(pct.strip("%")) if pct.endswith("%") else None

))

except (ValueError, TypeError):

continue

"""Return the top N largest directories (by total size) on the mount, any depth."""

if not which("du"):

return []

# -x: one filesystem; -B1: sizes in bytes; no -d: all directories recursively

# Use _run_allow_nonzero: du exits 1 on "Permission denied" but still prints valid data

out = _run_allow_nonzero(["du", "-x", "-B1", mountpoint], timeout=timeout)

rows: List[Tuple[int, str]] = []

mount_rstrip = mountpoint.rstrip("/")

for line in out.splitlines():

parts = line.strip().split("\t", 1)

if len(parts) != 2:

parts = line.strip().split(None, 1)

if len(parts) != 2:

continue

try:

size = int(parts[0])

path = parts[1].rstrip("/")

if path == mount_rstrip:

continue

rows.append((size, path))

except (ValueError, IndexError):

continue

rows.sort(key=lambda x: x[0], reverse=True)

"""Return the top N largest files on the mount. Uses heap so we only keep top N in memory."""

if not which("find"):

return []

top_n = max(1, int(top))

# Use _run_allow_nonzero: find can exit 1 on permission denied but still output valid lines

text = _run_allow_nonzero(

["find", mountpoint, "-xdev", "-type", "f", "-printf", r"%s\t%p\n"],

timeout=timeout,

)

if not text:

return []

# Min-heap: keep only top N by size (heap[0] = smallest of the top N)

heap: List[Tuple[int, str]] = []

for line in text.splitlines():

parts = line.strip().split("\t", 1)

if len(parts) != 2:

continue

try:

size = int(parts[0])

path = parts[1]

except ValueError:

continue

if len(heap) < top_n:

heapq.heappush(heap, (size, path))

elif size > heap[0][0]:

heapq.heapreplace(heap, (size, path))

heap.sort(key=lambda x: x[0], reverse=True)

os_info = get_os_info()

sys_info = get_system_info()

storage_hw_raw = get_lsblk()

devices = normalize_devices(storage_hw_raw) if storage_hw_raw else []

mounts = get_mounts()

gpus = get_gpu_info()

scanned = 0

for m in mounts:

if not deep:

continue

# Skip remote/special filesystems (cannot reliably run du/find)

fstype = (m.get("fstype") or "").lower()

dev = (m.get("device") or "").lower()

if fstype.startswith("nfs") or fstype.startswith("cifs") or fstype in ("smbfs", "fuse.sshfs") or dev.startswith("overlay"):

continue

# Optional cap: max_mounts <= 0 means no limit (scan all local filesystems)

if max_mounts > 0 and scanned >= max_mounts:

continue

m["largest_dirs"] = [

{"path": p, "size_bytes": int(sz)}

for sz, p in largest_dirs(m["mountpoint"], top_n, per_mount_timeout)

]

m["largest_files"] = [

{"path": p, "size_bytes": int(sz)}

for sz, p in largest_files(m["mountpoint"], top_n, per_mount_timeout)

]

scanned += 1

return {

"generated_at": _dt.datetime.now().isoformat(timespec="seconds"),

"os": os_info,

"system": sys_info,

"cpu": get_cpu_info(),

"memory": get_memory_info(),

"gpu": gpus,

"storage": {"devices": devices, "mounts": mounts},

c = color

lines: List[str] = []

H = lambda s: f"{c.BOLD}{c.C}{s}{c.RESET}"

# Header timestamp

ts = report.get("generated_at")

if ts:

lines.append(f"{c.DIM}Generated at: {ts}{c.RESET}\n")

# System

sysi = report.get("system", {}) or {}

lines.append(H("Computer — System"))

lines.append(f"{c.BOLD}Vendor/Model:{c.RESET} {sysi.get('vendor') or 'N/A'} {sysi.get('product_name') or ''}".rstrip())

lines.append(f"{c.BOLD}Version:{c.RESET} {sysi.get('product_version') or 'N/A'} {c.DIM}Serial:{c.RESET} {sysi.get('serial') or 'N/A'}")

chv = sysi.get("chassis_vendor"); cht = sysi.get("chassis_type")

if chv or cht:

lines.append(f"{c.DIM}Chassis:{c.RESET} {chv or '—'} type={cht or '—'}")

mb = sysi.get("motherboard") or {}

lines.append(f"{c.BOLD}Motherboard:{c.RESET} {mb.get('vendor') or 'N/A'} {mb.get('name') or ''}".rstrip())

lines.append(f" {c.DIM}Version:{c.RESET} {mb.get('version') or 'N/A'} {c.DIM}Serial:{c.RESET} {mb.get('serial') or 'N/A'}\n")

# OS

osi = report.get("os", {}) or {}

lines.append(H("OS"))

pn = osi.get("pretty_name") or f"{osi.get('name') or 'N/A'} {osi.get('version') or ''}".strip()

lines.append(f"{c.BOLD}{pn}{c.RESET}")

lines.append(f"{c.DIM}Kernel:{c.RESET} {osi.get('kernel') or 'N/A'} {c.DIM}Arch:{c.RESET} {osi.get('architecture') or 'N/A'}\n")

# CPU

cpu = report.get("cpu", {})

lines.append(H("CPU"))

lines.append(f"{c.BOLD}Model:{c.RESET} {cpu.get('model') or 'N/A'}")

lines.append(f"{c.BOLD}Vendor:{c.RESET} {cpu.get('vendor') or 'N/A'} {c.DIM}Arch:{c.RESET} {cpu.get('architecture') or 'N/A'}")

lines.append(f"{c.BOLD}Cores:{c.RESET} {cpu.get('physical_cores') or 'N/A'} phys / {cpu.get('logical_cores') or 'N/A'} logical")

base = human_bytes(cpu.get("base_freq_hz")) if cpu.get("base_freq_hz") else "N/A"

mx = human_bytes(cpu.get("max_freq_hz")) if cpu.get("max_freq_hz") else "N/A"

lines.append(f"{c.BOLD}Freq:{c.RESET} base≈{base} max≈{mx}")

util = cpu.get("current_utilization_percent")

util_s = f"{util:.1f}%" if isinstance(util, (int, float)) else "N/A"

util_color = c.G if isinstance(util, (int, float)) and util < 60 else (c.Y if isinstance(util, (int, float)) and util < 85 else c.R)

lines.append(f"{c.BOLD}Util:{c.RESET} {util_color}{util_s}{c.RESET}\n")

# Memory (totals only)

mem = report.get("memory", {})

lines.append(H("Memory"))

lines.append(f"Total {c.BOLD}{human_bytes(mem.get('total_bytes'))}{c.RESET} "

f"Used {c.Y}{human_bytes(mem.get('used_bytes'))}{c.RESET} "

f"Free {c.G}{human_bytes(mem.get('free_bytes'))}{c.RESET} "

f"Avail {c.G}{human_bytes(mem.get('available_bytes'))}{c.RESET}")

mp = mem.get("usage_percent")

mp_s = f"{mp:.1f}%" if isinstance(mp, (int, float)) else "N/A"

lines.append(f"Usage: {c.BOLD}{mp_s}{c.RESET}")

lines.append(f"{c.DIM}Swap:{c.RESET} total {human_bytes(mem.get('swap_total_bytes'))}, "

f"used {human_bytes(mem.get('swap_used_bytes'))}, "

f"free {human_bytes(mem.get('swap_free_bytes'))}\n")

# GPU

lines.append(H("GPU"))

gpus = report.get("gpu") or []

if not gpus:

lines.append(f"{c.DIM}(No GPU adapters detected; consider installing lshw or NVIDIA drivers){c.RESET}\n")

else:

for g in gpus: