systeminformation 5.9.5 → 5.9.9

package/lib/dockerSocket.js

@@ -321,7 +321,7 @@ class DockerSocket {
     } catch (err) {
       callback({});
     }
-  }  
+  }
 }
 
 module.exports = DockerSocket;

package/lib/filesystem.js

@@ -395,25 +395,26 @@ function blockDevices(callback) {
       if (_windows) {
         let drivetypes = ['Unknown', 'NoRoot', 'Removable', 'Local', 'Network', 'CD/DVD', 'RAM'];
         try {
-          util.wmic('logicaldisk get Caption,Description,DeviceID,DriveType,FileSystem,FreeSpace,Name,Size,VolumeName,VolumeSerialNumber /value').then((stdout, error) => {
+          // util.wmic('logicaldisk get Caption,Description,DeviceID,DriveType,FileSystem,FreeSpace,Name,Size,VolumeName,VolumeSerialNumber /value').then((stdout, error) => {
+          util.powerShell('Get-CimInstance -ClassName Win32_LogicalDisk | Format-List *').then((stdout, error) => {
             if (!error) {
               let devices = stdout.toString().split(/\n\s*\n/);
               devices.forEach(function (device) {
                 let lines = device.split('\r\n');
-                let drivetype = util.getValue(lines, 'drivetype', '=');
+                let drivetype = util.getValue(lines, 'drivetype', ':');
                 if (drivetype) {
                   data.push({
-                    name: util.getValue(lines, 'name', '='),
-                    identifier: util.getValue(lines, 'caption', '='),
+                    name: util.getValue(lines, 'name', ':'),
+                    identifier: util.getValue(lines, 'caption', ':'),
                     type: 'disk',
-                    fsType: util.getValue(lines, 'filesystem', '=').toLowerCase(),
-                    mount: util.getValue(lines, 'caption', '='),
-                    size: util.getValue(lines, 'size', '='),
+                    fsType: util.getValue(lines, 'filesystem', ':').toLowerCase(),
+                    mount: util.getValue(lines, 'caption', ':'),
+                    size: util.getValue(lines, 'size', ':'),
                     physical: (drivetype >= 0 && drivetype <= 6) ? drivetypes[drivetype] : drivetypes[0],
-                    uuid: util.getValue(lines, 'volumeserialnumber', '='),
-                    label: util.getValue(lines, 'volumename', '='),
+                    uuid: util.getValue(lines, 'volumeserialnumber', ':'),
+                    label: util.getValue(lines, 'volumename', ':'),
                     model: '',
-                    serial: util.getValue(lines, 'volumeserialnumber', '='),
+                    serial: util.getValue(lines, 'volumeserialnumber', ':'),
                     removable: drivetype === '2',
                     protocol: ''
                   });
@@ -783,7 +784,7 @@ function diskLayout(callback) {
       { pattern: '^IC.+', manufacturer: 'Hitachi' },
       { pattern: '^HTS.+', manufacturer: 'Hitachi' },
       { pattern: '^SANDISK.+', manufacturer: 'SanDisk' },
-      { pattern: '^KINGSTON.+', manufacturer: 'Kingston Technonogy' },
+      { pattern: '^KINGSTON.+', manufacturer: 'Kingston Technology' },
       { pattern: '^SONY.+', manufacturer: 'Sony' },
       { pattern: '^TRANSCEND.+', manufacturer: 'Transcend' },
       { pattern: 'SAMSUNG.+', manufacturer: 'Samsung' },
@@ -1162,7 +1163,7 @@ function diskLayout(callback) {
       if (_windows) {
         try {
           const workload = [];
-          workload.push(util.wmic('diskdrive get /value'));
+          workload.push(util.powerShell('Get-WmiObject Win32_DiskDrive | fl *'));
           workload.push(util.powerShell('Get-PhysicalDisk | Format-List'));
           if (util.smartMonToolsInstalled()) {
             try {
@@ -1182,25 +1183,25 @@ function diskLayout(callback) {
             let devices = data.results[0].toString().split(/\n\s*\n/);
             devices.forEach(function (device) {
               let lines = device.split('\r\n');
-              const size = util.getValue(lines, 'Size', '=').trim();
-              const status = util.getValue(lines, 'Status', '=').trim().toLowerCase();
+              const size = util.getValue(lines, 'Size', ':').trim();
+              const status = util.getValue(lines, 'Status', ':').trim().toLowerCase();
               if (size) {
                 result.push({
-                  device: util.getValue(lines, 'PNPDeviceId', '='),
+                  device: util.getValue(lines, 'PNPDeviceId', ':'),
                   type: device.indexOf('SSD') > -1 ? 'SSD' : 'HD',  // just a starting point ... better: MSFT_PhysicalDisk - Media Type ... see below
-                  name: util.getValue(lines, 'Caption', '='),
-                  vendor: getVendorFromModel(util.getValue(lines, 'Caption', '=', true).trim()),
+                  name: util.getValue(lines, 'Caption', ':'),
+                  vendor: getVendorFromModel(util.getValue(lines, 'Caption', ':', true).trim()),
                   size: parseInt(size),
-                  bytesPerSector: parseInt(util.getValue(lines, 'BytesPerSector', '=')),
-                  totalCylinders: parseInt(util.getValue(lines, 'TotalCylinders', '=')),
-                  totalHeads: parseInt(util.getValue(lines, 'TotalHeads', '=')),
-                  totalSectors: parseInt(util.getValue(lines, 'TotalSectors', '=')),
-                  totalTracks: parseInt(util.getValue(lines, 'TotalTracks', '=')),
-                  tracksPerCylinder: parseInt(util.getValue(lines, 'TracksPerCylinder', '=')),
-                  sectorsPerTrack: parseInt(util.getValue(lines, 'SectorsPerTrack', '=')),
-                  firmwareRevision: util.getValue(lines, 'FirmwareRevision', '=').trim(),
-                  serialNum: util.getValue(lines, 'SerialNumber', '=').trim(),
-                  interfaceType: util.getValue(lines, 'InterfaceType', '=').trim(),
+                  bytesPerSector: parseInt(util.getValue(lines, 'BytesPerSector', ':')),
+                  totalCylinders: parseInt(util.getValue(lines, 'TotalCylinders', ':')),
+                  totalHeads: parseInt(util.getValue(lines, 'TotalHeads', ':')),
+                  totalSectors: parseInt(util.getValue(lines, 'TotalSectors', ':')),
+                  totalTracks: parseInt(util.getValue(lines, 'TotalTracks', ':')),
+                  tracksPerCylinder: parseInt(util.getValue(lines, 'TracksPerCylinder', ':')),
+                  sectorsPerTrack: parseInt(util.getValue(lines, 'SectorsPerTrack', ':')),
+                  firmwareRevision: util.getValue(lines, 'FirmwareRevision', ':').trim(),
+                  serialNum: util.getValue(lines, 'SerialNumber', ':').trim(),
+                  interfaceType: util.getValue(lines, 'InterfaceType', ':').trim(),
                   smartStatus: (status === 'ok' ? 'Ok' : (status === 'degraded' ? 'Degraded' : (status === 'pred fail' ? 'Predicted Failure' : 'Unknown'))),
                   temperature: null,
                 });

package/lib/graphics.js

@@ -13,7 +13,6 @@
 // 7. Graphics (controller, display)
 // ----------------------------------------------------------------------------------
 
-const os = require('os');
 const fs = require('fs');
 const exec = require('child_process').exec;
 const execSync = require('child_process').execSync;
@@ -769,9 +768,9 @@ function graphics(callback) {
         // https://devblogs.microsoft.com/scripting/use-powershell-to-discover-multi-monitor-information/
         try {
           const workload = [];
-          workload.push(util.wmic('path win32_VideoController get /value'));
+          workload.push(util.powerShell('Get-WmiObject win32_VideoController | fl *'));
           workload.push(util.powerShell('gp "HKLM:\\SYSTEM\\ControlSet001\\Control\\Class\\{4d36e968-e325-11ce-bfc1-08002be10318}\\*" -ErrorAction SilentlyContinue | where MatchingDeviceId $null -NE | select MatchingDeviceId,HardwareInformation.qwMemorySize | fl'));
-          workload.push(util.wmic('path win32_desktopmonitor get /value'));
+          workload.push(util.powerShell('Get-WmiObject win32_desktopmonitor | fl *'));
           workload.push(util.powerShell('Get-CimInstance -Namespace root\\wmi -ClassName WmiMonitorBasicDisplayParams | fl'));
           workload.push(util.powerShell('Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::AllScreens'));
           workload.push(util.powerShell('Get-CimInstance -Namespace root\\wmi -ClassName WmiMonitorConnectionParams | fl'));
@@ -783,13 +782,13 @@ function graphics(callback) {
             workload
           ).then(data => {
             // controller + vram
-            let csections = data[0].split(/\n\s*\n/);
-            let vsections = data[1].split(/\n\s*\n/);
+            let csections = data[0].replace(/\r/g, '').split(/\n\s*\n/);
+            let vsections = data[1].replace(/\r/g, '').split(/\n\s*\n/);
             result.controllers = parseLinesWindowsControllers(csections, vsections);
             result.controllers = result.controllers.map((controller) => { // match by subDeviceId
               if (controller.vendor.toLowerCase() === 'nvidia') {
                 return mergeControllerNvidia(controller, nvidiaData.find(device => {
-                  let windowsSubDeviceId = controller.subDeviceId.toLowerCase();
+                  let windowsSubDeviceId = (controller.subDeviceId || '').toLowerCase();
                   const nvidiaSubDeviceIdParts = device.subDeviceId.split('x');
                   let nvidiaSubDeviceId = nvidiaSubDeviceIdParts.length > 1 ? nvidiaSubDeviceIdParts[1].toLowerCase() : nvidiaSubDeviceIdParts[0].toLowerCase();
                   const lengthDifference = Math.abs(windowsSubDeviceId.length - nvidiaSubDeviceId.length);
@@ -810,25 +809,25 @@ function graphics(callback) {
             });
 
             // displays
-            let dsections = data[2].split(/\n\s*\n/);
+            let dsections = data[2].replace(/\r/g, '').split(/\n\s*\n/);
             // result.displays = parseLinesWindowsDisplays(dsections);
-            dsections.shift();
-            dsections.pop();
+            if (dsections[0].trim() === '') { dsections.shift(); }
+            if (dsections.length && dsections[dsections.length - 1].trim() === '') { dsections.pop(); }
 
             // monitor (powershell)
-            let msections = data[3].split('Active ');
+            let msections = data[3].replace(/\r/g, '').split('Active ');
             msections.shift();
 
             // forms.screens (powershell)
-            let ssections = data[4].split('BitsPerPixel ');
+            let ssections = data[4].replace(/\r/g, '').split('BitsPerPixel ');
             ssections.shift();
 
             // connection params (powershell) - video type
-            let tsections = data[5].split(/\n\s*\n/);
+            let tsections = data[5].replace(/\r/g, '').split(/\n\s*\n/);
             tsections.shift();
 
             // monitor ID (powershell) - model / vendor
-            const res = data[6].split(/\r\n/);
+            const res = data[6].replace(/\r/g, '').split(/\n/);
             let isections = [];
             res.forEach(element => {
               const parts = element.split('|');
@@ -842,6 +841,7 @@ function graphics(callback) {
                 });
               }
             });
+
             result.displays = parseLinesWindowsDisplaysPowershell(ssections, msections, dsections, tsections, isections);
 
             if (result.displays.length === 1) {
@@ -889,7 +889,7 @@ function graphics(callback) {
     for (const i in vections) {
       if ({}.hasOwnProperty.call(vections, i)) {
         if (vections[i].trim() !== '') {
-          const lines = vections[i].trim().split(os.EOL);
+          const lines = vections[i].trim().split('\n');
           const matchingDeviceId = util.getValue(lines, 'MatchingDeviceId').match(/PCI\\(VEN_[0-9A-F]{4})&(DEV_[0-9A-F]{4})(?:&(SUBSYS_[0-9A-F]{8}))?(?:&(REV_[0-9A-F]{2}))?/i);
           if (matchingDeviceId) {
             const quadWordmemorySize = parseInt(util.getValue(lines, 'HardwareInformation.qwMemorySize'));
@@ -912,12 +912,12 @@ function graphics(callback) {
     for (let i in sections) {
       if ({}.hasOwnProperty.call(sections, i)) {
         if (sections[i].trim() !== '') {
-          let lines = sections[i].trim().split('\r\n');
-          let pnpDeviceId = util.getValue(lines, 'PNPDeviceID', '=').match(/PCI\\(VEN_[0-9A-F]{4})&(DEV_[0-9A-F]{4})(?:&(SUBSYS_[0-9A-F]{8}))?(?:&(REV_[0-9A-F]{2}))?/i);
+          let lines = sections[i].trim().split('\n');
+          let pnpDeviceId = util.getValue(lines, 'PNPDeviceID', ':').match(/PCI\\(VEN_[0-9A-F]{4})&(DEV_[0-9A-F]{4})(?:&(SUBSYS_[0-9A-F]{8}))?(?:&(REV_[0-9A-F]{2}))?/i);
           let subDeviceId = null;
           let memorySize = null;
           if (pnpDeviceId) {
-            subDeviceId = pnpDeviceId[3];
+            subDeviceId = pnpDeviceId[3] || '';
             if (subDeviceId) {
               subDeviceId = subDeviceId.split('_')[1];
             }
@@ -959,17 +959,17 @@ function graphics(callback) {
           }
 
           controllers.push({
-            vendor: util.getValue(lines, 'AdapterCompatibility', '='),
-            model: util.getValue(lines, 'name', '='),
-            bus: util.getValue(lines, 'PNPDeviceID', '=').startsWith('PCI') ? 'PCI' : '',
-            vram: (memorySize == null ? util.toInt(util.getValue(lines, 'AdapterRAM', '=')) : memorySize) / 1024 / 1024,
-            vramDynamic: (util.getValue(lines, 'VideoMemoryType', '=') === '2'),
+            vendor: util.getValue(lines, 'AdapterCompatibility', ':'),
+            model: util.getValue(lines, 'name', ':'),
+            bus: util.getValue(lines, 'PNPDeviceID', ':').startsWith('PCI') ? 'PCI' : '',
+            vram: (memorySize == null ? util.toInt(util.getValue(lines, 'AdapterRAM', ':')) : memorySize) / 1024 / 1024,
+            vramDynamic: (util.getValue(lines, 'VideoMemoryType', ':') === '2'),
             subDeviceId
           });
-          _resolutionX = util.toInt(util.getValue(lines, 'CurrentHorizontalResolution', '=')) || _resolutionX;
-          _resolutionY = util.toInt(util.getValue(lines, 'CurrentVerticalResolution', '=')) || _resolutionY;
-          _refreshRate = util.toInt(util.getValue(lines, 'CurrentRefreshRate', '=')) || _refreshRate;
-          _pixelDepth = util.toInt(util.getValue(lines, 'CurrentBitsPerPixel', '=')) || _pixelDepth;
+          _resolutionX = util.toInt(util.getValue(lines, 'CurrentHorizontalResolution', ':')) || _resolutionX;
+          _resolutionY = util.toInt(util.getValue(lines, 'CurrentVerticalResolution', ':')) || _resolutionY;
+          _refreshRate = util.toInt(util.getValue(lines, 'CurrentRefreshRate', ':')) || _refreshRate;
+          _pixelDepth = util.toInt(util.getValue(lines, 'CurrentBitsPerPixel', ':')) || _pixelDepth;
         }
       }
     }
@@ -984,12 +984,12 @@ function graphics(callback) {
     let resolutionX = 0;
     let resolutionY = 0;
     if (dsections && dsections.length) {
-      let linesDisplay = dsections[0].split(os.EOL);
-      vendor = util.getValue(linesDisplay, 'MonitorManufacturer', '=');
-      model = util.getValue(linesDisplay, 'Name', '=');
-      deviceID = util.getValue(linesDisplay, 'PNPDeviceID', '=').replace(/&/g, '&').toLowerCase();
-      resolutionX = util.toInt(util.getValue(linesDisplay, 'ScreenWidth', '='));
-      resolutionY = util.toInt(util.getValue(linesDisplay, 'ScreenHeight', '='));
+      let linesDisplay = dsections[0].split('\n');
+      vendor = util.getValue(linesDisplay, 'MonitorManufacturer', ':');
+      model = util.getValue(linesDisplay, 'Name', ':');
+      deviceID = util.getValue(linesDisplay, 'PNPDeviceID', ':').replace(/&/g, '&').toLowerCase();
+      resolutionX = util.toInt(util.getValue(linesDisplay, 'ScreenWidth', ':'));
+      resolutionY = util.toInt(util.getValue(linesDisplay, 'ScreenHeight', ':'));
     }
     for (let i = 0; i < ssections.length; i++) {
       if (ssections[i].trim() !== '') {
@@ -1000,12 +1000,12 @@ function graphics(callback) {
         if (tsections.length === 0 || tsections[i] === undefined) {
           tsections[i] = 'Unknown';
         }
-        let linesScreen = ssections[i].split(os.EOL);
-        let linesMonitor = msections[i].split(os.EOL);
+        let linesScreen = ssections[i].split('\n');
+        let linesMonitor = msections[i].split('\n');
 
-        let linesConnection = tsections[i].split(os.EOL);
+        let linesConnection = tsections[i].split('\n');
         const bitsPerPixel = util.getValue(linesScreen, 'BitsPerPixel');
-        const bounds = util.getValue(linesScreen, 'Bounds').replace('{', '').replace('}', '').split(',');
+        const bounds = util.getValue(linesScreen, 'Bounds').replace('{', '').replace('}', '').replace(/=/g, ':').split(',');
         const primary = util.getValue(linesScreen, 'Primary');
         const sizeX = util.getValue(linesMonitor, 'MaxHorizontalImageSize');
         const sizeY = util.getValue(linesMonitor, 'MaxVerticalImageSize');
@@ -1027,15 +1027,15 @@ function graphics(callback) {
           main: primary.toLowerCase() === 'true',
           builtin: videoOutputTechnology === '2147483648',
           connection: videoOutputTechnology && videoTypes[videoOutputTechnology] ? videoTypes[videoOutputTechnology] : '',
-          resolutionX: util.toInt(util.getValue(bounds, 'Width', '=')),
-          resolutionY: util.toInt(util.getValue(bounds, 'Height', '=')),
+          resolutionX: util.toInt(util.getValue(bounds, 'Width', ':')),
+          resolutionY: util.toInt(util.getValue(bounds, 'Height', ':')),
           sizeX: sizeX ? parseInt(sizeX, 10) : null,
           sizeY: sizeY ? parseInt(sizeY, 10) : null,
           pixelDepth: bitsPerPixel,
-          currentResX: util.toInt(util.getValue(bounds, 'Width', '=')),
-          currentResY: util.toInt(util.getValue(bounds, 'Height', '=')),
-          positionX: util.toInt(util.getValue(bounds, 'X', '=')),
-          positionY: util.toInt(util.getValue(bounds, 'Y', '=')),
+          currentResX: util.toInt(util.getValue(bounds, 'Width', ':')),
+          currentResY: util.toInt(util.getValue(bounds, 'Height', ':')),
+          positionX: util.toInt(util.getValue(bounds, 'X', ':')),
+          positionY: util.toInt(util.getValue(bounds, 'Y', ':')),
         });
       }
     }
@@ -1057,7 +1057,6 @@ function graphics(callback) {
     }
     return displays;
   }
-
 }
 
 exports.graphics = graphics;

package/lib/index.d.ts

@@ -48,6 +48,8 @@ export namespace Systeminformation {
     version: string;
     serial: string;
     assetTag: string;
+    memMax: number | null;
+    memSlots: number | null;
   }
 
   interface ChassisData {
@@ -127,14 +129,15 @@ export namespace Systeminformation {
     size: number;
     bank: string;
     type: string;
-    ecc?: boolean;
-    clockSpeed: number;
+    ecc?: boolean | null;
+    clockSpeed: number | null;
     formFactor: string;
+    manufacturer?: string;
     partNum: string;
     serialNum: string;
-    voltageConfigured: number;
-    voltageMin: number;
-    voltageMax: number;
+    voltageConfigured: number | null;
+    voltageMin: number | null;
+    voltageMax: number | null;
   }
 
   interface SmartData {
@@ -360,11 +363,13 @@ export namespace Systeminformation {
     uefi: boolean;
     hypervizor?: boolean;
     remoteSession?: boolean;
+    hypervisor?: boolean;
   }
 
   interface UuidData {
     os: string;
     hardware: string;
+    macs: string[];
   }
 
   interface VersionData {
@@ -537,6 +542,7 @@ export namespace Systeminformation {
     iface: string;
     model: string;
     vendor: string;
+    mac: string;
   }
 
   interface WifiConnectionData {
@@ -655,7 +661,7 @@ export namespace Systeminformation {
     bridgeNfIptables: boolean;
     bridgeNfIp6tables: boolean;
     debug: boolean;
-    mfd: number;
+    nfd: number;
     oomKillDisable: boolean;
     ngoroutines: number;
     systemTime: string;
@@ -741,6 +747,7 @@ export namespace Systeminformation {
     memLimit: number;
     memPercent: number;
     cpuPercent: number;
+    pids: number;
     netIO: {
       rx: number;
       wx: number;
@@ -756,6 +763,23 @@ export namespace Systeminformation {
     networks: any;
   }
 
+  interface DockerContainerProcessData {
+    pidHost: string;
+    ppid: string;
+    pgid: string;
+    user: string;
+    ruser: string;
+    group: string;
+    rgroup: string;
+    stat: string;
+    time: string;
+    elapsed: string;
+    nice: string;
+    rss: string;
+    vsz: string;
+    command: string;
+  }
+
   interface DockerVolumeData {
     name: string;
     driver: string;
@@ -931,7 +955,7 @@ export function dockerInfo(cb?: (data: Systeminformation.DockerInfoData) => any)
 export function dockerImages(all?: boolean, cb?: (data: Systeminformation.DockerImageData[]) => any): Promise<Systeminformation.DockerImageData[]>;
 export function dockerContainers(all?: boolean, cb?: (data: Systeminformation.DockerContainerData[]) => any): Promise<Systeminformation.DockerContainerData[]>;
 export function dockerContainerStats(id?: string, cb?: (data: Systeminformation.DockerContainerStatsData[]) => any): Promise<Systeminformation.DockerContainerStatsData[]>;
-export function dockerContainerProcesses(id?: string, cb?: (data: any) => any): Promise<any>;
+export function dockerContainerProcesses(id?: string, cb?: (data: any) => any): Promise<Systeminformation.DockerContainerProcessData[]>;
 export function dockerVolumes(cb?: (data: Systeminformation.DockerVolumeData[]) => any): Promise<Systeminformation.DockerVolumeData[]>;
 export function dockerAll(cb?: (data: any) => any): Promise<any>;
 

package/lib/memory.js

@@ -256,14 +256,14 @@ function mem(callback) {
         let swaptotal = 0;
         let swapused = 0;
         try {
-          util.wmic('pagefile get AllocatedBaseSize, CurrentUsage').then((stdout, error) => {
+          util.powerShell('Get-CimInstance Win32_PageFileUsage | Select AllocatedBaseSize, CurrentUsage').then((stdout, error) => {
             if (!error) {
               let lines = stdout.split('\r\n').filter(line => line.trim() !== '').filter((line, idx) => idx > 0);
               lines.forEach(function (line) {
                 if (line !== '') {
                   line = line.trim().split(/\s\s+/);
-                  swaptotal = swaptotal + parseInt(line[0], 10);
-                  swapused = swapused + parseInt(line[1], 10);
+                  swaptotal = swaptotal + (parseInt(line[0], 10) || 0);
+                  swapused = swapused + (parseInt(line[1], 10) || 0);
                 }
               });
             }
@@ -329,9 +329,9 @@ function memLayout(callback) {
                   manufacturer: getManufacturerLinux(util.getValue(lines, 'Manufacturer:')),
                   partNum: util.getValue(lines, 'Part Number:'),
                   serialNum: util.getValue(lines, 'Serial Number:'),
-                  voltageConfigured: parseFloat(util.getValue(lines, 'Configured Voltage:') || null),
-                  voltageMin: parseFloat(util.getValue(lines, 'Minimum Voltage:') || null),
-                  voltageMax: parseFloat(util.getValue(lines, 'Maximum Voltage:') || null),
+                  voltageConfigured: parseFloat(util.getValue(lines, 'Configured Voltage:')) || null,
+                  voltageMin: parseFloat(util.getValue(lines, 'Minimum Voltage:')) || null,
+                  voltageMax: parseFloat(util.getValue(lines, 'Maximum Voltage:'))|| null,
                 });
               } else {
                 result.push({
@@ -384,14 +384,14 @@ function memLayout(callback) {
                 result[0].type = version && version[2] && version[2] === '3' ? 'LPDDR4' : result[0].type;
                 result[0].ecc = false;
                 result[0].clockSpeed = version && version[2] && clockSpeed[version[2]] || 400;
-                result[0].clockSpeed = version && version[4] && version[4] === 'd' ? '500' : result[0].clockSpeed;
+                result[0].clockSpeed = version && version[4] && version[4] === 'd' ? 500 : result[0].clockSpeed;
                 result[0].formFactor = 'SoC';
 
                 stdout = execSync('vcgencmd get_config sdram_freq 2>/dev/null');
                 lines = stdout.toString().split('\n');
                 let freq = parseInt(util.getValue(lines, 'sdram_freq', '=', true), 10) || 0;
                 if (freq) {
-                  result.clockSpeed = freq;
+                  result[0].clockSpeed = freq;
                 }
 
                 stdout = execSync('vcgencmd measure_volts sdram_p 2>/dev/null');
@@ -469,7 +469,7 @@ function memLayout(callback) {
             if (size && type) {
               result.push({
                 size: size * 1024 * 1024 * 1024,
-                bank: 0,
+                bank: '0',
                 type,
                 ecc: false,
                 clockSpeed: 0,
@@ -497,28 +497,31 @@ function memLayout(callback) {
         const FormFactors = 'Unknown|Other|SIP|DIP|ZIP|SOJ|Proprietary|SIMM|DIMM|TSOP|PGA|RIMM|SODIMM|SRIMM|SMD|SSMP|QFP|TQFP|SOIC|LCC|PLCC|BGA|FPBGA|LGA'.split('|');
 
         try {
-          util.wmic('memorychip get /value').then((stdout, error) => {
+          util.powerShell('Get-WmiObject Win32_PhysicalMemory | fl *').then((stdout, error) => {
             if (!error) {
-              let devices = stdout.toString().split('BankL');
+              let devices = stdout.toString().split(/\n\s*\n/);
               devices.shift();
               devices.forEach(function (device) {
                 let lines = device.split('\r\n');
-                const dataWidth = util.toInt(util.getValue(lines, 'DataWidth', '='));
-                const totalWidth = util.toInt(util.getValue(lines, 'TotalWidth', '='));
-                result.push({
-                  size: parseInt(util.getValue(lines, 'Capacity', '='), 10) || 0,
-                  bank: util.getValue(lines, 'abel', '='), // BankLabel
-                  type: memoryTypes[parseInt(util.getValue(lines, 'MemoryType', '='), 10) || parseInt(util.getValue(lines, 'SMBIOSMemoryType', '='), 10)],
-                  ecc: dataWidth && totalWidth ? totalWidth > dataWidth : false,
-                  clockSpeed: parseInt(util.getValue(lines, 'ConfiguredClockSpeed', '='), 10) || parseInt(util.getValue(lines, 'Speed', '='), 10) || 0,
-                  formFactor: FormFactors[parseInt(util.getValue(lines, 'FormFactor', '='), 10) || 0],
-                  manufacturer: util.getValue(lines, 'Manufacturer', '='),
-                  partNum: util.getValue(lines, 'PartNumber', '='),
-                  serialNum: util.getValue(lines, 'SerialNumber', '='),
-                  voltageConfigured: (parseInt(util.getValue(lines, 'ConfiguredVoltage', '='), 10) || 0) / 1000.0,
-                  voltageMin: (parseInt(util.getValue(lines, 'MinVoltage', '='), 10) || 0) / 1000.0,
-                  voltageMax: (parseInt(util.getValue(lines, 'MaxVoltage', '='), 10) || 0) / 1000.0,
-                });
+                const dataWidth = util.toInt(util.getValue(lines, 'DataWidth', ':'));
+                const totalWidth = util.toInt(util.getValue(lines, 'TotalWidth', ':'));
+                const size = parseInt(util.getValue(lines, 'Capacity', ':'), 10) || 0;
+                if (size) {
+                  result.push({
+                    size,
+                    bank: util.getValue(lines, 'BankLabel', ':'), // BankLabel
+                    type: memoryTypes[parseInt(util.getValue(lines, 'MemoryType', ':'), 10) || parseInt(util.getValue(lines, 'SMBIOSMemoryType', ':'), 10)],
+                    ecc: dataWidth && totalWidth ? totalWidth > dataWidth : false,
+                    clockSpeed: parseInt(util.getValue(lines, 'ConfiguredClockSpeed', ':'), 10) || parseInt(util.getValue(lines, 'Speed', ':'), 10) || 0,
+                    formFactor: FormFactors[parseInt(util.getValue(lines, 'FormFactor', ':'), 10) || 0],
+                    manufacturer: util.getValue(lines, 'Manufacturer', ':'),
+                    partNum: util.getValue(lines, 'PartNumber', ':'),
+                    serialNum: util.getValue(lines, 'SerialNumber', ':'),
+                    voltageConfigured: (parseInt(util.getValue(lines, 'ConfiguredVoltage', ':'), 10) || 0) / 1000.0,
+                    voltageMin: (parseInt(util.getValue(lines, 'MinVoltage', ':'), 10) || 0) / 1000.0,
+                    voltageMax: (parseInt(util.getValue(lines, 'MaxVoltage', ':'), 10) || 0) / 1000.0,
+                  });
+                }
               });
             }
             if (callback) { callback(result); }