@oxmc/node-smbios 1.0.0

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@oxmc/node-smbios",
+  "version": "1.0.0",
+  "description": "A Node.js module designed to retrieve detailed system and hardware information from SMBIOS.",
+  "main": "index.js",
+  "scripts": {
+    "install": "node-pre-gyp install --fallback-to-build",
+    "build": "node-gyp rebuild",
+    "clean": "node-gyp clean",
+    "test": "node example.js",
+    "package": "node-pre-gyp package",
+    "publish-binary": "node-pre-gyp-github publish"
+  },
+  "binary": {
+    "module_name": "smbios",
+    "module_path": "./build/Release/",
+    "package_name": "{module_name}-v{version}-{node_abi}-{platform}-{arch}.tar.gz",
+    "host": "https://github.com/oxmc/node-smbios/releases/download/",
+    "remote_path": "v{version}"
+  },
+  "keywords": [
+    "smbios",
+    "dmi",
+    "system-information",
+    "hardware",
+    "bios",
+    "motherboard",
+    "baseboard",
+    "processor",
+    "cpu",
+    "memory",
+    "ram",
+    "chassis",
+    "native",
+    "addon",
+    "cross-platform",
+    "windows",
+    "linux",
+    "macos",
+    "system-info",
+    "hardware-info"
+  ],
+  "author": "Seth Olivarez <me@oxmc.me> (https://oxmc.me)",
+  "license": "GPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxmc/node-smbios.git"
+  },
+  "bugs": {
+    "url": "https://github.com/oxmc/node-smbios/issues"
+  },
+  "homepage": "https://github.com/oxmc/node-smbios#readme",
+  "gypfile": true,
+  "dependencies": {
+    "@mapbox/node-pre-gyp": "^2.0.3",
+    "node-addon-api": "^8.0.0"
+  },
+  "devDependencies": {
+    "node-gyp": "^10.0.0",
+    "node-pre-gyp-github": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}

package/src/binding.cpp

@@ -0,0 +1,266 @@
+#include <napi.h>
+#include "smbios_common.h"
+
+namespace smbios {
+
+/**
+ * Convert BiosInfo struct to JavaScript object
+ */
+Napi::Object BiosInfoToObject(Napi::Env env, const BiosInfo& info) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("vendor", Napi::String::New(env, info.vendor));
+    obj.Set("version", Napi::String::New(env, info.version));
+    obj.Set("releaseDate", Napi::String::New(env, info.releaseDate));
+    obj.Set("biosCharacteristics", Napi::String::New(env, info.biosCharacteristics));
+    return obj;
+}
+
+/**
+ * Convert SystemInfo struct to JavaScript object
+ */
+Napi::Object SystemInfoToObject(Napi::Env env, const SystemInfo& info) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("manufacturer", Napi::String::New(env, info.manufacturer));
+    obj.Set("productName", Napi::String::New(env, info.productName));
+    obj.Set("serialNumber", Napi::String::New(env, info.serialNumber));
+    obj.Set("uuid", Napi::String::New(env, info.uuid));
+    obj.Set("skuNumber", Napi::String::New(env, info.skuNumber));
+    obj.Set("family", Napi::String::New(env, info.family));
+    obj.Set("wakeUpType", Napi::String::New(env, info.wakeUpType));
+    return obj;
+}
+
+/**
+ * Convert BoardInfo struct to JavaScript object
+ */
+Napi::Object BoardInfoToObject(Napi::Env env, const BoardInfo& info) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("manufacturer", Napi::String::New(env, info.manufacturer));
+    obj.Set("product", Napi::String::New(env, info.product));
+    obj.Set("version", Napi::String::New(env, info.version));
+    obj.Set("serialNumber", Napi::String::New(env, info.serialNumber));
+    obj.Set("assetTag", Napi::String::New(env, info.assetTag));
+    obj.Set("locationInChassis", Napi::String::New(env, info.locationInChassis));
+    return obj;
+}
+
+/**
+ * Convert ProcessorInfo struct to JavaScript object
+ */
+Napi::Object ProcessorInfoToObject(Napi::Env env, const ProcessorInfo& info) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("manufacturer", Napi::String::New(env, info.manufacturer));
+    obj.Set("version", Napi::String::New(env, info.version));
+    obj.Set("socketDesignation", Napi::String::New(env, info.socketDesignation));
+    obj.Set("processorType", Napi::String::New(env, info.processorType));
+    obj.Set("processorFamily", Napi::String::New(env, info.processorFamily));
+    obj.Set("maxSpeed", Napi::String::New(env, info.maxSpeed));
+    obj.Set("currentSpeed", Napi::String::New(env, info.currentSpeed));
+    obj.Set("coreCount", Napi::String::New(env, info.coreCount));
+    obj.Set("threadCount", Napi::String::New(env, info.threadCount));
+    obj.Set("l2CacheSize", Napi::String::New(env, info.l2CacheSize));
+    obj.Set("l3CacheSize", Napi::String::New(env, info.l3CacheSize));
+    return obj;
+}
+
+/**
+ * Convert MemoryInfo struct to JavaScript object
+ */
+Napi::Object MemoryInfoToObject(Napi::Env env, const MemoryInfo& info) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("totalPhysicalMemory", Napi::String::New(env, info.totalPhysicalMemory));
+    obj.Set("availablePhysicalMemory", Napi::String::New(env, info.availablePhysicalMemory));
+    obj.Set("totalVirtualMemory", Napi::String::New(env, info.totalVirtualMemory));
+    obj.Set("availableVirtualMemory", Napi::String::New(env, info.availableVirtualMemory));
+    obj.Set("memoryDevices", Napi::String::New(env, info.memoryDevices));
+    obj.Set("maxCapacity", Napi::String::New(env, info.maxCapacity));
+    return obj;
+}
+
+/**
+ * Convert ChassisInfo struct to JavaScript object
+ */
+Napi::Object ChassisInfoToObject(Napi::Env env, const ChassisInfo& info) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("manufacturer", Napi::String::New(env, info.manufacturer));
+    obj.Set("type", Napi::String::New(env, info.type));
+    obj.Set("version", Napi::String::New(env, info.version));
+    obj.Set("serialNumber", Napi::String::New(env, info.serialNumber));
+    obj.Set("assetTag", Napi::String::New(env, info.assetTag));
+    obj.Set("bootUpState", Napi::String::New(env, info.bootUpState));
+    obj.Set("powerSupplyState", Napi::String::New(env, info.powerSupplyState));
+    obj.Set("thermalState", Napi::String::New(env, info.thermalState));
+    return obj;
+}
+
+/**
+ * Node.js binding: getBiosInfo()
+ */
+Napi::Value GetBiosInfoWrapped(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        BiosInfo biosInfo = GetBiosInfo();
+        return BiosInfoToObject(env, biosInfo);
+    } catch (const std::exception& e) {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+/**
+ * Node.js binding: getSystemInfo()
+ */
+Napi::Value GetSystemInfoWrapped(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        SystemInfo systemInfo = GetSystemInfo();
+        return SystemInfoToObject(env, systemInfo);
+    } catch (const std::exception& e) {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+/**
+ * Node.js binding: getBoardInfo()
+ */
+Napi::Value GetBoardInfoWrapped(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        BoardInfo boardInfo = GetBoardInfo();
+        return BoardInfoToObject(env, boardInfo);
+    } catch (const std::exception& e) {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+/**
+ * Node.js binding: getProcessorInfo()
+ */
+Napi::Value GetProcessorInfoWrapped(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        ProcessorInfo procInfo = GetProcessorInfo();
+        return ProcessorInfoToObject(env, procInfo);
+    } catch (const std::exception& e) {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+/**
+ * Node.js binding: getMemoryInfo()
+ */
+Napi::Value GetMemoryInfoWrapped(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        MemoryInfo memInfo = GetMemoryInfo();
+        return MemoryInfoToObject(env, memInfo);
+    } catch (const std::exception& e) {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+/**
+ * Node.js binding: getChassisInfo()
+ */
+Napi::Value GetChassisInfoWrapped(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        ChassisInfo chassisInfo = GetChassisInfo();
+        return ChassisInfoToObject(env, chassisInfo);
+    } catch (const std::exception& e) {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+/**
+ * Node.js binding: getAllInfo()
+ * Returns all information in a single call
+ */
+Napi::Value GetAllInfoWrapped(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        Napi::Object result = Napi::Object::New(env);
+        
+        BiosInfo biosInfo = GetBiosInfo();
+        SystemInfo systemInfo = GetSystemInfo();
+        BoardInfo boardInfo = GetBoardInfo();
+        ProcessorInfo procInfo = GetProcessorInfo();
+        MemoryInfo memInfo = GetMemoryInfo();
+        ChassisInfo chassisInfo = GetChassisInfo();
+        
+        result.Set("bios", BiosInfoToObject(env, biosInfo));
+        result.Set("system", SystemInfoToObject(env, systemInfo));
+        result.Set("board", BoardInfoToObject(env, boardInfo));
+        result.Set("processor", ProcessorInfoToObject(env, procInfo));
+        result.Set("memory", MemoryInfoToObject(env, memInfo));
+        result.Set("chassis", ChassisInfoToObject(env, chassisInfo));
+        
+        return result;
+    } catch (const std::exception& e) {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+/**
+ * Initialize the Node.js addon
+ */
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports.Set(
+        Napi::String::New(env, "getBiosInfo"),
+        Napi::Function::New(env, GetBiosInfoWrapped)
+    );
+    
+    exports.Set(
+        Napi::String::New(env, "getSystemInfo"),
+        Napi::Function::New(env, GetSystemInfoWrapped)
+    );
+    
+    exports.Set(
+        Napi::String::New(env, "getBoardInfo"),
+        Napi::Function::New(env, GetBoardInfoWrapped)
+    );
+    
+    exports.Set(
+        Napi::String::New(env, "getProcessorInfo"),
+        Napi::Function::New(env, GetProcessorInfoWrapped)
+    );
+    
+    exports.Set(
+        Napi::String::New(env, "getMemoryInfo"),
+        Napi::Function::New(env, GetMemoryInfoWrapped)
+    );
+    
+    exports.Set(
+        Napi::String::New(env, "getChassisInfo"),
+        Napi::Function::New(env, GetChassisInfoWrapped)
+    );
+    
+    exports.Set(
+        Napi::String::New(env, "getAllInfo"),
+        Napi::Function::New(env, GetAllInfoWrapped)
+    );
+    
+    return exports;
+}
+
+} // namespace smbios
+
+// Register the addon (must be outside namespace)
+Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
+    return smbios::Init(env, exports);
+}
+
+NODE_API_MODULE(addon, InitModule)

package/src/linux/smbios_linux.cpp

@@ -0,0 +1,214 @@
+#include "../smbios_common.h"
+
+#ifdef __linux__
+
+#include <fstream>
+#include <string>
+
+namespace smbios {
+
+// DMI information is typically available in /sys/class/dmi/id/
+const std::string DMI_PATH = "/sys/class/dmi/id/";
+
+/**
+ * Read DMI file content
+ */
+std::string ReadDMI(const std::string& filename) {
+    std::string path = DMI_PATH + filename;
+    return ReadFile(path);
+}
+
+BiosInfo GetBiosInfo() {
+    BiosInfo info;
+    
+    info.vendor = ReadDMI("bios_vendor");
+    info.version = ReadDMI("bios_version");
+    info.releaseDate = ReadDMI("bios_date");
+    info.biosCharacteristics = ReadDMI("modalias");
+    
+    return info;
+}
+
+SystemInfo GetSystemInfo() {
+    SystemInfo info;
+    
+    info.manufacturer = ReadDMI("sys_vendor");
+    info.productName = ReadDMI("product_name");
+    info.serialNumber = ReadDMI("product_serial");
+    info.uuid = ReadDMI("product_uuid");
+    info.skuNumber = ReadDMI("product_sku");
+    info.family = ReadDMI("product_family");
+    info.wakeUpType = ReadDMI("chassis_type");
+    
+    // Clean up common placeholder values
+    if (info.serialNumber == "To Be Filled By O.E.M." || 
+        info.serialNumber == "System Serial Number" ||
+        info.serialNumber == "0") {
+        info.serialNumber = "";
+    }
+    
+    if (info.uuid == "To Be Filled By O.E.M." || 
+        info.uuid == "00000000-0000-0000-0000-000000000000") {
+        info.uuid = "";
+    }
+    
+    return info;
+}
+
+BoardInfo GetBoardInfo() {
+    BoardInfo info;
+    
+    info.manufacturer = ReadDMI("board_vendor");
+    info.product = ReadDMI("board_name");
+    info.version = ReadDMI("board_version");
+    info.serialNumber = ReadDMI("board_serial");
+    info.assetTag = ReadDMI("board_asset_tag");
+    info.locationInChassis = ReadDMI("chassis_vendor");
+    
+    // Clean up common placeholder values
+    if (info.serialNumber == "To Be Filled By O.E.M." || 
+        info.serialNumber == "Board Serial Number" ||
+        info.serialNumber == "0") {
+        info.serialNumber = "";
+    }
+    
+    if (info.assetTag == "To Be Filled By O.E.M." || 
+        info.assetTag == "Asset Tag" ||
+        info.assetTag == "0") {
+        info.assetTag = "";
+    }
+    
+    return info;
+}
+
+ProcessorInfo GetProcessorInfo() {
+    ProcessorInfo info;
+    
+    // Try to read from /proc/cpuinfo
+    std::ifstream cpuinfo("/proc/cpuinfo");
+    if (cpuinfo.is_open()) {
+        std::string line;
+        while (std::getline(cpuinfo, line)) {
+            if (line.find("vendor_id") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.manufacturer = TrimString(line.substr(pos + 1));
+                }
+            } else if (line.find("model name") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.version = TrimString(line.substr(pos + 1));
+                }
+            } else if (line.find("cpu family") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.processorFamily = TrimString(line.substr(pos + 1));
+                }
+            } else if (line.find("cpu MHz") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.currentSpeed = TrimString(line.substr(pos + 1));
+                }
+            } else if (line.find("cpu cores") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.coreCount = TrimString(line.substr(pos + 1));
+                }
+            } else if (line.find("siblings") != std::string::npos && info.threadCount.empty()) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.threadCount = TrimString(line.substr(pos + 1));
+                }
+            }
+        }
+        cpuinfo.close();
+    }
+    
+    info.socketDesignation = "CPU Socket";
+    info.processorType = "Central Processor";
+    info.maxSpeed = info.currentSpeed; // Approximation
+    
+    // Try to get cache sizes
+    std::string l2Cache = ReadFile("/sys/devices/system/cpu/cpu0/cache/index2/size");
+    if (!l2Cache.empty()) {
+        info.l2CacheSize = l2Cache;
+    }
+    
+    std::string l3Cache = ReadFile("/sys/devices/system/cpu/cpu0/cache/index3/size");
+    if (!l3Cache.empty()) {
+        info.l3CacheSize = l3Cache;
+    }
+    
+    return info;
+}
+
+MemoryInfo GetMemoryInfo() {
+    MemoryInfo info;
+    
+    // Read from /proc/meminfo
+    std::ifstream meminfo("/proc/meminfo");
+    if (meminfo.is_open()) {
+        std::string line;
+        while (std::getline(meminfo, line)) {
+            if (line.find("MemTotal") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    std::string value = TrimString(line.substr(pos + 1));
+                    // Convert from KB to bytes
+                    try {
+                        size_t kb = std::stoull(value);
+                        info.totalPhysicalMemory = std::to_string(kb * 1024);
+                    } catch (...) {
+                        info.totalPhysicalMemory = value;
+                    }
+                }
+            } else if (line.find("MemAvailable") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    std::string value = TrimString(line.substr(pos + 1));
+                    try {
+                        size_t kb = std::stoull(value);
+                        info.availablePhysicalMemory = std::to_string(kb * 1024);
+                    } catch (...) {
+                        info.availablePhysicalMemory = value;
+                    }
+                }
+            } else if (line.find("SwapTotal") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.totalVirtualMemory = TrimString(line.substr(pos + 1));
+                }
+            } else if (line.find("SwapFree") != std::string::npos) {
+                size_t pos = line.find(":");
+                if (pos != std::string::npos) {
+                    info.availableVirtualMemory = TrimString(line.substr(pos + 1));
+                }
+            }
+        }
+        meminfo.close();
+    }
+    
+    info.memoryDevices = "N/A";
+    info.maxCapacity = info.totalPhysicalMemory;
+    
+    return info;
+}
+
+ChassisInfo GetChassisInfo() {
+    ChassisInfo info;
+    
+    info.manufacturer = ReadDMI("chassis_vendor");
+    info.type = ReadDMI("chassis_type");
+    info.version = ReadDMI("chassis_version");
+    info.serialNumber = ReadDMI("chassis_serial");
+    info.assetTag = ReadDMI("chassis_asset_tag");
+    info.bootUpState = "Normal";
+    info.powerSupplyState = "Safe";
+    info.thermalState = "Safe";
+    
+    return info;
+}
+
+} // namespace smbios
+
+#endif // __linux__