jsm-sysinfo


comprehensive system monitoring implementation using the systeminformation npm package with TypeScript.
This will provide structured JSON output with both raw values and human-readable formats.I've created a comprehensive system monitoring implementation using the systeminformation npm package with TypeScript.
Here's what the implementation provides:

Installation

``bash
npm install jsm-sysinfo
`

Key Features:

1. Structured JSON Output: Every piece of data includes:

- name: Programmatic identifier
- label: Human-readable label
- value: Raw value
- humanValue: Formatted, human-readable value
- unit: Optional unit of measurement

2. Comprehensive Monitoring Sections:

- System Information (manufacturer, model, OS, etc.)
- CPU Information (brand, cores, load, temperature)
- Memory Information (RAM, swap usage)
- Disk Information (physical disks and filesystems)
- Network Information (interfaces and statistics)
- Process Information (counts and top processes)
- System Load & Uptime
- Battery Information (if available)

3. Utility Methods:

- getSystemMonitoringData(): Get all system data at once
- getSection(sectionName): Get specific section data
- startMonitoring(): Continuous monitoring with callback

4. Data Formatting:
- Bytes to human-readable format (KB, MB, GB, etc.)
- Percentages with decimal precision
- Temperature formatting
- Uptime formatting (days, hours, minutes, seconds)

Installation Requirements:

`bash
npm install jsm-sysinfo
`

Usage Examples:

`typescript
import { SystemMonitor } from "jsm-sysinfo";

// One-time monitoring
const monitor = new SystemMonitor();
const data = await monitor.getSystemMonitoringData();
console.log(JSON.stringify(data, null, 2));

// Continuous monitoring
const intervalId = monitor.startMonitoring(5000, (data) => {
// Process monitoring data every 5 seconds
console.log(data);
});

// Get specific section
const cpuData = await monitor.getSection("cpu");
`

Example usage demonstrating various features of the SystemMonitor
@example

`typescript
import SystemMonitor, { IMonitorConfig } from "jsm-sysinfo";

async function demonstrateSystemMonitoring() {
// Create monitor with custom configuration
const config: IMonitorConfig = {
includeTemperature: true,
includeProcesses: true,
maxProcesses: 10,
includeNetworkStats: true,
includeBattery: true,
timeoutMs: 15000,
};

const monitor = new SystemMonitor(config);

try {
// Get quick overview
console.log("=== System Summary ===");
const summary = await monitor.getQuickSummary();
Object.entries(summary).forEach(([key, value]) => {
console.log(${key}: ${value});
});

console.log("\n=== Full System Data ===");
// Get complete system data
const fullData = await monitor.collectAll();
console.log(JSON.stringify(fullData, null, 2));

// Get specific sections
console.log("\n=== CPU Section Only ===");
const cpuData = await monitor.getSection("cpu");
if (cpuData) {
cpuData.fields.forEach((field) => {
console.log(${field.label}: ${field.humanValue});
});
}

// Start continuous monitoring
console.log("\n=== Starting Continuous Monitoring ===");
const stopMonitoring = monitor.startContinuousMonitoring(
10000,
(data, error) => {
if (error) {
console.error("Monitoring error:", error.message);
return;
}

if (data) {
const cpuSection = data.sections.find((s) => s.section === "CPU");
const memSection = data.sections.find((s) => s.section === "Memory");

const cpuLoad =
cpuSection?.fields.find((f) => f.name === "currentLoad")
?.humanValue || "N/A";
const memUsage =
memSection?.fields.find((f) => f.name === "usagePercent")
?.humanValue || "N/A";

console.log(
[${new Date().toLocaleTimeString()}] CPU: ${cpuLoad}, Memory: ${memUsage}
);
}
}
);

// Stop monitoring after 30 seconds
setTimeout(() => {
stopMonitoring();
console.log("Continuous monitoring stopped");
}, 30000);
} catch (error: any) {
console.error("System monitoring error:", error);
}
}

// Run the demonstration
// demonstrateSystemMonitoring();
`

@example

`typescript
// Simple usage for basic monitoring
import SystemMonitor from "jsm-sysinfo";

async function basicMonitoring() {
const monitor = new SystemMonitor();

// Get all data once
const data = await monitor.collectAll();

// Extract key metrics
const cpuSection = data.sections.find((s) => s.section === "CPU");
const memSection = data.sections.find((s) => s.section === "Memory");

const cpuBrand = cpuSection?.fields.find(
(f) => f.name === "brand"
)?.humanValue;
const cpuLoad = cpuSection?.fields.find(
(f) => f.name === "currentLoad"
)?.humanValue;
const memTotal = memSection?.fields.find(
(f) => f.name === "total"
)?.humanValue;
const memUsage = memSection?.fields.find(
(f) => f.name === "usagePercent"
)?.humanValue;

console.log(System: ${data.hostname});
console.log(CPU: ${cpuBrand} - Load: ${cpuLoad});
console.log(Memory: ${memUsage} of ${memTotal} used);
console.log(Uptime: ${formatDuration(data.uptime)});
console.log(Data collected in ${data.summary.collectionTimeMs}ms);
}
`

@example

`typescript
// Advanced usage with custom configuration and filtering
import SystemMonitor, {
IMonitoringSection,
IMonitoringField,
} from "jsm-sysinfo";

async function advancedMonitoring() {
const monitor = new SystemMonitor({
includeTemperature: true,
includeProcesses: true,
maxProcesses: 3,
includeNetworkStats: false,
includeBattery: false,
});

const data = await monitor.collectAll();

// Filter and display only performance-related metrics
data.sections.forEach((section) => {
console.log(\n=== ${section.section} ===);

const performanceFields = section.fields.filter(
(field) =>
field.metadata?.category === "performance" ||
field.metadata?.realtime === true
);

performanceFields.forEach((field) => {
console.log( ${field.label}: ${field.humanValue});
if (field.metadata?.sensitive) {
console.log( [SENSITIVE DATA]);
}
});
});

// Find all temperature readings
const tempFields: IMonitoringField[] = [];
data.sections.forEach((section) => {
section.fields.forEach((field) => {
if (field.metadata?.category === "thermal") {
tempFields.push(field);
}
});
});

if (tempFields.length > 0) {
console.log("\n=== Temperature Readings ===");
tempFields.forEach((field) => {
console.log( ${field.label}: ${field.humanValue});
});
}
}
``

The implementation follows TypeScript best practices with proper type definitions, error handling, and modular design. Each monitoring field provides both raw data for programmatic use and formatted values for display purposes.