Added OS info, updated CPU info

Author: luca-vogels

.github/workflows/on-push.yml

@@ -0,0 +1,35 @@
+name: On Push
+on: [push]
+jobs:
+  build:
+    name: Building
+    runs-on: Linux
+    steps:
+      - name: Checking out repository
+        uses: actions/checkout@v4
+      - name: "Setup Node"
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+      - name: Installing 
+        run: npm install
+      - name: Building
+        run: npm run build
+  
+  testing:
+    name: Testing
+    needs: build
+    runs-on: Linux
+    steps:
+      - name: "Setup Node"
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+      - name: Installing 
+        run: npm install
+      - name: Running linter
+        run: npm run lint
+      - name: Running tests
+        run:  npm run test

README.md

@@ -10,31 +10,56 @@ Node module that provides utilities for interacting with the operating system an
 
 JavaScript:
 ```javascript
-const osUtils = require('lup-system');
+const lupSystem = 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));
+lupSystem.getCpuInfo().then(cpuInfo => console.log("CPU Info: " + cpuInfo));
+lupSystem.getDrives().then(drives => console.log("Drives: " + drives)); // Array of drive objects
+lupSystem.getGPUs().then(gpus => console.log("GPU Info: " + gpus));
+lupSystem.getNetworkInterfaces().then(interfaces => console.log("Network Interfaces: " + interfaces));
+lupSystem.getOSInfo().then(osInfo => console.log("OS Info: " + osInfo));
+lupSystem.getTemperatures().then(temps => console.log("Temperatures: " + temps));
 ```
 
 TypeScript:
 ```typescript
-import osUtils from 'lup-system';
+import lupSystem from 'lup-system';
 
 (async () => {
-    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());
+    console.log("CPU Info: ", await lupSystem.getCpuInfo());
+    console.log("Drives: ", await lupSystem.getDrives()); // Array of drive objects
+    console.log("GPU Info: ", await lupSystem.getGPUs());
+    console.log("Network Interfaces: ", await lupSystem.getNetworkInterfaces());
+    console.log("OS Info: ", await lupSystem.getOSInfo());
+    console.log("Temperatures: ", await lupSystem.getTemperatures());
 })();
 ```
 
 Output:
 ```
-CPU Utilization: 0.2313135420902806
+CPU Info: {
+    architecture: 'x64',
+    coreCount: 12,
+    endian: 'LE',
+    name: '11th Gen Intel(R) Core(TM) i5-11600K @ 3.90GHz',
+    speed: 3912,
+    utilization: {
+        overall: 0.20021299254526093,
+        cores: [
+            0.20253164556962025,
+            0.19230769230769232,
+            0.6025641025641025,
+            0,
+            0.3974358974358974,
+            0.20253164556962025,
+            0,
+            0,
+            0.20253164556962025,
+            0,
+            0.19480519480519481,
+            0.4050632911392405
+        ]
+    }
+}
 Drives: [
     {
         filesystem: 'C:',
@@ -55,6 +80,24 @@ Drives: [
         utilization: 0.08308232033236287
     }
 ]
+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
+    }
+]
 Network Interfaces: [
     {
         name: 'Loopback Pseudo-Interface 1',
@@ -74,24 +117,16 @@ 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
-    }
-]
+OS Info: {
+    name: 'Windows',
+    version: '10.0.26100',
+    architecture: 'x64',
+    machine: 'x86_64',
+    platform: 'win32',
+    bits: 64,
+    hostname: 'my-pc',
+    uptime: 2025-07-25T09:38:27.126Z
+}
 Temperatures: {
     cpu: 45.2,
     gpu: 60.8,

TODO.txt

@@ -0,0 +1 @@
+memory.ts

package.json

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

src/__tests__/CPU.test.ts

@@ -1,8 +1,8 @@
-import { getCpuUtilization, stopCpuUtilizationComputation } from '../cpu';
+import { getCpuInfo, stopCpuUtilizationComputation } from '../cpu';
 
-test('getCpuUtilization', async () => {
-  const utilization = await getCpuUtilization();
-  console.log('CPU utilization:', utilization); // TODO REMOVE
+test('getCpuInfo', async () => {
+  const cpuInfo = await getCpuInfo();
+  console.log('CPU Info:', cpuInfo); // TODO REMOVE
 });
 
 afterAll(() => {

src/__tests__/OS.test.ts

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

src/cpu.ts

@@ -23,8 +23,8 @@ export type CPU = {
   /** CPU architecture (e.g., x64, arm64). */
   architecture: string;
 
-  /** CPU model (e.g., Intel Core i7-9700K). */
-  model: string;
+  /** Endianness of the CPU (e.g., LE for little-endian, BE for big-endian). */
+  endian: 'LE' | 'BE';
 
   /** CPU speed in MHz. */
   speed: number;
@@ -43,17 +43,19 @@ export let CPU_COMPUTE_UTILIZATION_INTERVAL = 1000;
 const CPU_COMPUTE_UTILIZATION_INITIAL_DELAY = 50;
 
 let PREV_CPU_CORES: os.CpuInfo[] = [];
-let CPU_CORE_UTILIZATIONS: number[] = [];
-let CPU_UTILIZATION: number = 0;
+const CPU_UTILIZATION: CPUUtilization = {
+  overall: 0,
+  cores: []
+};
 let CPU_COMPUTE_RUNNING = false;
 let CPU_COMPUTE_TIMEOUT: NodeJS.Timeout | null = null;
 
 async function computeCpuUtilization() {
   const cpuCores = os.cpus();
   const min = Math.min(cpuCores.length, PREV_CPU_CORES.length);
-  if (CPU_CORE_UTILIZATIONS.length < min)
-    for (let i = CPU_CORE_UTILIZATIONS.length; i < min; i++) CPU_CORE_UTILIZATIONS.push(0);
-  else if (CPU_CORE_UTILIZATIONS.length > min) CPU_CORE_UTILIZATIONS = CPU_CORE_UTILIZATIONS.slice(0, min);
+  if (CPU_UTILIZATION.cores.length < min)
+    for (let i = CPU_UTILIZATION.cores.length; i < min; i++) CPU_UTILIZATION.cores.push(0);
+  else if (CPU_UTILIZATION.cores.length > min) CPU_UTILIZATION.cores = CPU_UTILIZATION.cores.slice(0, min);
 
   let totalUsage = 0;
   let totalTotal = 0;
@@ -69,11 +71,11 @@ async function computeCpuUtilization() {
     const prevTotal = prevUsage + prev.times.idle;
     const total = nextTotal - prevTotal;
 
-    CPU_CORE_UTILIZATIONS[i] = usage / total;
+    CPU_UTILIZATION.cores[i] = usage / total;
     totalUsage += usage;
     totalTotal += total;
   }
-  CPU_UTILIZATION = totalTotal !== 0 ? totalUsage / totalTotal : 0;
+  CPU_UTILIZATION.overall = totalTotal !== 0 ? totalUsage / totalTotal : 0;
   PREV_CPU_CORES = cpuCores;
 }
 
@@ -95,39 +97,48 @@ export function stopCpuUtilizationComputation() {
 }
 
 
+
 /**
- * Returns the number of CPU cores available on the system.
- *
- * @returns Number of CPU cores.
+ * Returns information about the CPU.
+ * 
+ * @returns CPU information.
  */
-export function getCpuCoreCount(): number {
-  return os.cpus().length;
+export async function getCpuInfo(): Promise<CPU> {
+  const cpuCores = os.cpus();
+  return {
+    architecture: os.arch(),
+    coreCount: cpuCores.length,
+    endian: os.endianness() as 'LE' | 'BE',
+    name: cpuCores[0].model,
+    speed: cpuCores[0].speed,
+    utilization: await getCpuUtilization(),
+  }
 }
 
+
 /**
- * Returns the utilization of each CPU core as a percentage (0.0-1.0).
- *
- * @returns List of CPU core utilizations as percentages (0.0-1.0).
+ * Returns the current CPU utilization.
+ * If the computation is not running, it will start the computation and return the initial values.
+ * 
+ * @returns CPU utilization data.
  */
-export async function getCpuCoreUtilization(): Promise<number[]> {
+export async function getCpuUtilization(): Promise<CPUUtilization> {
   if (!CPU_COMPUTE_RUNNING) {
     await runCpuComputeInterval(); // runs the first computation immediately
     await sleep(CPU_COMPUTE_UTILIZATION_INITIAL_DELAY); // wait a bit to get initial values
     await computeCpuUtilization(); // run second computation immediately to get initial values
   }
-  return CPU_CORE_UTILIZATIONS;
+  return CPU_UTILIZATION;
 }
 
+
+
 /**
- * Returns the overall CPU utilization as a percentage (0.0-1.0).
+ * Returns the number of CPU cores available on the system.
  *
- * @returns Overall CPU utilization as a percentage (0.0-1.0).
+ * @returns Number of CPU cores.
  */
-export async function getCpuUtilization(): Promise<number> {
-  if (!CPU_COMPUTE_RUNNING) {
-    await runCpuComputeInterval(); // runs the first computation immediately
-    await sleep(CPU_COMPUTE_UTILIZATION_INITIAL_DELAY); // wait a bit to get initial values
-    await computeCpuUtilization(); // run second computation immediately to get initial values
-  }
-  return CPU_UTILIZATION;
+export function getCpuCoreCount(): number {
+  return os.cpus().length;
 }
+

src/index.ts

@@ -2,6 +2,7 @@ import * as cpu from './cpu';
 import * as drive from './drive';
 import * as gpu from './gpu';
 import * as net from './net';
+import * as os from './os';
 import * as temperatures from './temperature';
 import * as utils from './utils';
 
@@ -13,6 +14,7 @@ const osUtils = {
   ...drive,
   ...gpu,
   ...net,
+  ...os,
   ...temperatures,
   ...utils,
 };

src/os.ts

@@ -0,0 +1,58 @@
+import os from 'os';
+
+export type OSInfo = {
+
+    /** Name of the operating system (e.g., Windows, Linux, macOS). */
+    name: string;
+
+    /** Version of the operating system (e.g., 10.0.19042 for Windows 10). */
+    version: string;
+
+    /** 
+     * Architecture of the operating system (e.g., x64, arm64). 
+     * This refers to the CPU architecture, which indicates the type of processor and instruction set used by the operating system.
+     * For example, x64 is used for 64-bit Intel/AMD processors, while arm64 is used for 64-bit ARM processors.
+     */
+    architecture: string;
+
+    /** 
+     * Machine type (e.g., x86_64, armv7l). 
+     * The difference between architecture and machine is that architecture refers to the CPU architecture, while machine refers to the specific hardware platform
+     * like x86_64 for 64-bit Intel/AMD processors or armv7l for 32-bit ARM processors.
+     */
+    machine: string;
+
+    /** 
+     * Platform of the operating system (e.g., win32, linux, darwin). 
+     * This indicates the underlying platform on which the operating system is running.
+     * For example, win32 is used for Windows, linux for Linux distributions, and darwin for macOS.
+     */
+    platform: string;
+
+    /** Number of bits in the operating system (e.g., 32 or 64). */
+    bits: number;
+
+    /** Hostname of the machine. */
+    hostname: string;
+
+    /** Date since when the system has been booted. */
+    uptime?: Date;
+};
+
+/**
+ * Returns information about the operating system.
+ * 
+ * @returns Operating system information.
+ */
+export async function getOSInfo(): Promise<OSInfo> {
+    return {
+        name: os.type().replaceAll('_NT', ''), // normalize name
+        version: os.release(),
+        architecture: os.arch(),
+        machine: os.machine(),
+        platform: os.platform(),
+        bits: os.arch().includes('64') ? 64 : 32,
+        hostname: os.hostname(),
+        uptime: new Date(Date.now() - os.uptime() * 1000)
+    };
+}