Added GPU and temperature readings

Author: luca-vogels

README.md

@@ -15,6 +15,7 @@ const osUtils = require('lup-system');
 osUtils.getCpuUtilization().then(utilization => console.log("CPU Utilization: " + utilization));
 osUtils.getDrives().then(drives => console.log("Drives: " + drives)); // Array of drive objects
 osUtils.getNetworkInterfaces().then(interfaces => console.log("Network Interfaces: " + interfaces));
+osUtils.getGPUs().then(gpus => console.log("GPU Info: " + gpus));
 osUtils.getTemperatures().then(temps => console.log("Temperatures: " + temps));
 ```
 
@@ -26,6 +27,7 @@ import osUtils from 'lup-system';
     console.log("CPU Utilization: " + await osUtils.getCpuUtilization());
     console.log("Drives: ", await osUtils.getDrives()); // Array of drive objects
     console.log("Network Interfaces: ", await osUtils.getNetworkInterfaces());
+    console.log("GPU Info: ", await osUtils.getGPUs());
     console.log("Temperatures: ", await osUtils.getTemperatures());
 })();
 ```
@@ -72,8 +74,33 @@ Network Interfaces: [
         }
     }
 ]
+GPU Info: [
+    {
+        name: 'NVIDIA GeForce RTX 3060 Ti',
+        status: 'ok',
+        id: 'PCI\\VEN_10DE&DEV_2489&SUBSYS_884F1043&REV_A1\\4&2130FF93&0&0008',
+        processor: 'NVIDIA GeForce RTX 3060 Ti',
+        memory: 8589934592,
+        driverDate: '14.05.2025 02:00:00',
+        driverVersion: '32.0.15.7652',
+        displayAttached: true,
+        displayActive: true,
+        fanSpeed: 0.53,
+        utilization: 0.03,
+        memoryUtilization: 0.01,
+        temperature: 52,
+        powerDraw: 48.32
+    }
+]
 Temperatures: {
     cpu: 45.2,
     gpu: 60.8,
 }
-```
+```
+
+
+## Considerations
+
+### GPU Readings
+For more detailed information on GPUs it is recommended to 
+install the [nvidia-smi](https://developer.nvidia.com/nvidia-system-management-interface) tool.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "lup-system",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "NodeJS library to retrieve system information and utilization.",
   "files": [
     "lib/**/*"

package.json

@@ -0,0 +1,6 @@
+import { getGPUs } from '../gpu';
+
+test('getGPUs', async () => {
+  const gpus = await getGPUs();
+  console.log(gpus); // TODO REMOVE
+});

src/__tests__/GPU.test.ts

@@ -3,7 +3,7 @@ import { getNetworkInterfaces, stopNetworkUtilizationComputation } from '../net'
 test('getNetworkInterfaces', async () => {
   const nics = await getNetworkInterfaces();
   console.log(nics); // TODO REMOVE
-});
+}, 10000);
 
 afterAll(() => {
   stopNetworkUtilizationComputation();

src/__tests__/Net.test.ts

@@ -1,9 +1,45 @@
 import os from 'os';
 import { sleep } from './utils';
 
+
+export type CPUUtilization = {
+
+  /** Overall CPU utilization as a percentage (0.0-1.0). */
+  overall: number;
+
+  /** Utilization of each CPU core as a percentage (0.0-1.0). */
+  cores: number[];
+
+};
+
+export type CPU = {
+
+  /** Name of the CPU. */
+  name: string;
+
+  /** Number of CPU cores. */
+  coreCount: number;
+
+  /** CPU architecture (e.g., x64, arm64). */
+  architecture: string;
+
+  /** CPU model (e.g., Intel Core i7-9700K). */
+  model: string;
+
+  /** CPU speed in MHz. */
+  speed: number;
+
+  /** CPU utilization data. */
+  utilization: CPUUtilization;
+};
+
+
+
+
 /** Intervall in milliseconds at which CPU utilization is computed. */
 export let CPU_COMPUTE_UTILIZATION_INTERVAL = 1000;
 
+
 const CPU_COMPUTE_UTILIZATION_INITIAL_DELAY = 50;
 
 let PREV_CPU_CORES: os.CpuInfo[] = [];
@@ -58,6 +94,7 @@ export function stopCpuUtilizationComputation() {
   CPU_COMPUTE_RUNNING = false;
 }
 
+
 /**
  * Returns the number of CPU cores available on the system.
  *

src/cpu.ts

@@ -0,0 +1,169 @@
+import { execCommand } from "./utils";
+
+export type GPU = {
+    /** Unique ID of the GPU device. */
+    id: string;
+
+    /** Name of the GPU device. */
+    name: string;
+
+    /** Name of the processor built into the GPU. */
+    processor?: string;
+
+    /** Status of the GPU device. */
+    status: 'ok' | 'error' | 'unknown' | string;
+
+    /** Last update date of the GPU driver, if available. */
+    driverDate?: string;
+
+    /** Version of the GPU driver, if available. */
+    driverVersion?: string;
+
+    /** Memory size of the GPU in bytes. */
+    memory?: number;
+
+    /** Memory utilization of the GPU in percentage (0.0-1.0) */
+    memoryUtilization?: number;
+
+    /** Temperature of the memory in Celsius. */
+    memoryTemperature?: number;
+
+    /** GPU processing utilization in percentage (0.0-1.0) */
+    utilization?: number;
+
+    /** Index of the GPU device. */
+    index?: number;
+
+    /** If a physical display/monitor is attached to one of the GPU's connector.s */
+    displayAttached?: boolean;
+
+    /** If memory is allocated inside the GPU for display purposes. Can be true even if no physical display is attached. */
+    displayActive?: boolean;
+
+    /** Fan speed in percentage (0.0-1.0). */
+    fanSpeed?: number;
+
+    /** Temperature of the GPU in Celsius. */
+    temperature?: number;
+
+    /** Power draw of the GPU in watts. */
+    powerDraw?: number;
+};
+
+export async function getGPUs(): Promise<GPU[]> {
+    const gpus: GPU[] = [];
+    switch(process.platform){
+
+        case 'linux': {
+            const output = await execCommand('lspci -k | grep -i -A3 "\[vga\]\|\[3d\]"');
+            const lines = output.split('\n');
+            let curr: GPU | null = null;
+            // tslint:disable-next-line:prefer-for-of
+            for(let i=0; i < lines.length; i++){
+                const line = lines[i].trim();
+                if(!line) continue; // skip empty lines
+                if(line.startsWith('00:')){
+                    // new GPU found, push current if exists
+                    if(curr) gpus.push(curr);
+                    curr = {} as GPU;
+                    curr.id = line.split(' ')[0];
+                    curr.name = line.split(':')[2].trim();
+                    curr.status = 'ok'; // assume ok, will update later if needed
+                }
+            }
+            break;
+        }
+
+
+        case 'win32': {
+            const output = await execCommand('powershell -Command "Get-CimInstance -ClassName Win32_VideoController | Format-List"');
+            const lines = output.split('\n');
+            let curr: GPU | null = null;
+            // tslint:disable-next-line:prefer-for-of
+            for(let i=0; i < lines.length; i++){
+                const [key, value] = lines[i].split(' : ').map(s => s.trim());
+                if(!key && !value){
+                    // empty line, push current GPU if exists
+                    if(curr) gpus.push(curr);
+                    curr = null;
+                    continue;
+                }
+                if(!value) continue; // skip lines without value
+
+                if(key === 'Name'){
+                    if(!curr) curr = {} as any;
+                    curr!.name = value;
+                } else
+                if(key === 'Status'){
+                    if(!curr) curr = {} as any;
+                    curr!.status = value.toLowerCase() || 'unknown';
+                } else
+                if(key === 'PNPDeviceID'){
+                    if(!curr) curr = {} as any;
+                    curr!.id = value;
+                } else
+                if(key === 'VideoProcessor'){
+                    if(!curr) curr = {} as any;
+                    curr!.processor = value;
+                } else
+                if(key === 'AdapterRAM'){
+                    const memory = parseInt(value.trim(), 10);
+                    if(Number.isNaN(memory)) continue; // skip invalid memory values
+                    if(!curr) curr = {} as any;
+                    curr!.memory = memory; // not accurate, but gives an idea of the GPU memory
+                } else
+                if(key === 'DriverDate'){
+                    if(!curr) curr = {} as any;
+                    curr!.driverDate = value;
+                } else
+                if(key === 'DriverVersion'){
+                    if(!curr) curr = {} as any;
+                    curr!.driverVersion = value;
+                }
+            }
+            if(curr) gpus.push(curr);
+            break;
+        }
+
+    }
+
+    // nvidia-smi for more detailed info
+    {
+        const output = await execCommand('nvidia-smi --query-gpu=name,display_attached,display_active,fan.speed,memory.total,utilization.gpu,utilization.memory,temperature.gpu,temperature.memory,power.draw --format=csv,nounits,noheader').catch(() => '');
+        const lines = output.split('\n').filter(line => line.trim() !== '');
+        const updatedIndexes = new Set<number>();
+        // tslint:disable-next-line:prefer-for-of
+        for(let i = 0; i < lines.length; i++){
+            const [name, displayAttached, displayActive, fanSpeed, memoryTotal, utilizationGPU, utilizationMemory, temperatureGPU, temperatureMemory, powerDraw] = lines[i].split(',').map(s => s.trim());
+            let currIdx = gpus.length;
+            let currGpu: GPU | undefined = undefined;
+            for(let g = 0; g < gpus.length; g++){
+                if(updatedIndexes.has(g)) continue; // already updated this GPU
+                const gpu = gpus[g];
+                if(gpu.name !== name) continue;
+                updatedIndexes.add(g);
+                currIdx = g;
+                currGpu = gpus[g];
+                break;
+            }
+            if(!currGpu){
+                currGpu = { id: name, name } as GPU;
+                updatedIndexes.add(gpus.length);
+                gpus.push(currGpu);
+            }
+            if(displayAttached) currGpu.displayAttached = ['yes', 'enabled', '1' ].includes(displayAttached.toLowerCase());
+            if(displayActive) currGpu.displayActive = ['yes', 'enabled', '1' ].includes(displayActive.toLowerCase());
+            if(fanSpeed && !Number.isNaN(parseFloat(fanSpeed))) currGpu.fanSpeed = parseFloat(fanSpeed) / 100;
+            if(memoryTotal && !Number.isNaN(parseInt(memoryTotal, 10))) currGpu.memory = parseInt(memoryTotal, 10) * 1024 * 1024; // convert MiB to bytes
+            if(utilizationGPU && !Number.isNaN(parseFloat(utilizationGPU))) currGpu.utilization = parseFloat(utilizationGPU) / 100;
+            if(utilizationMemory && !Number.isNaN(parseFloat(utilizationMemory))) currGpu.memoryUtilization = parseFloat(utilizationMemory) / 100;
+            if(temperatureGPU && !Number.isNaN(parseFloat(temperatureGPU))) currGpu.temperature = parseFloat(temperatureGPU);
+            if(temperatureMemory && !Number.isNaN(parseFloat(temperatureMemory))) currGpu.memoryTemperature = parseFloat(temperatureMemory);
+            if(powerDraw && !Number.isNaN(parseFloat(powerDraw))) currGpu.powerDraw = parseFloat(powerDraw);
+            gpus[currIdx] = currGpu;
+        }
+        
+    }
+
+    return gpus;
+}

src/gpu.ts

@@ -1,5 +1,6 @@
 import * as cpu from './cpu';
 import * as drive from './drive';
+import * as gpu from './gpu';
 import * as net from './net';
 import * as temperatures from './temperature';
 import * as utils from './utils';
@@ -10,6 +11,7 @@ import * as utils from './utils';
 const osUtils = {
   ...cpu,
   ...drive,
+  ...gpu,
   ...net,
   ...temperatures,
   ...utils,

src/index.ts

@@ -0,0 +1,23 @@
+export type Memory = {
+
+    /** Memory size in bytes. */
+    size: number; // Size in bytes
+
+    /** Memory used in bytes. */
+    used: number;
+
+    /** Memory free in bytes. */
+    free: number;
+
+    /** Utilization of available memory in percentage (0.0-1.0). */
+    utilization: number;
+
+    /** Memory type (e.g., DDR4, LPDDR4X). */
+    type: string;
+
+    /** Memory clock speed in MHz. */
+    frequency: number;
+
+    /** Memory speed in bytes per second. */
+    speed: number;
+};