@daimazun/hardware-info 1.0.0

package/index.js

@@ -0,0 +1,192 @@
+const { readOhmTemp } = require('./lib/ohm');
+const { readPerfCounterTemp } = require('./lib/perfctr');
+const { readAllHardware } = require('./lib/allhardware');
+const { createCpuTempDaemon, CpuTempDaemon } = require('./lib/ohm-daemon');
+const { createCpuTempMonitor, CpuTempMonitor } = require('./lib/monitor');
+const { createSysInfoDaemon, SysInfoDaemon } = require('./lib/sysinfo-daemon');
+const { getSystemInfo } = require('./lib/system');
+const { getMemoryInfo } = require('./lib/memory');
+const { getDiskInfo } = require('./lib/disk');
+const { getNetworkInfo } = require('./lib/network');
+const { getBatteryInfo } = require('./lib/battery');
+const { getGpuInfo } = require('./lib/gpu');
+const { getServicesInfo } = require('./lib/services');
+const { getUsbInfo } = require('./lib/usb');
+const { getProcesses } = require('./lib/processes');
+const { killProcess, showItemInFolder, findPidsByPort, findPidsByName } = require('./lib/process-ops');
+const { createDiskWatcher, listDriveLetters } = require('./lib/disk-watcher');
+const { getProcessIcon, getProcessIcons } = require('./lib/process-icon');
+const { createHardwareService, HardwareService } = require('./lib/hardware-service');
+const { getPublicIp } = require('./lib/public-ip');
+const { getBackendUsage } = require('./lib/backend-usage');
+
+/**
+ * 获取 CPU 温度及完整 CPU 信息（多层降级）
+ * 管理员 → OpenHardwareService（真实核心温度 + 负载 + 频率 + 功耗）
+ * 非管理员 → 性能计数器（ACPI 热区温度）
+ */
+async function getCpuTemp(options = {}) {
+  const verbose = options.verbose || false;
+  const errors = [];
+
+  // 第一层：OpenHardwareService（真实核心温度，需管理员）
+  try {
+    const data = await readOhmTemp();
+    const result = {
+      source: 'openHardwareService',
+      isCoreTemp: true,
+      cpuName: data.cpuName,
+      temperature: data.temperature,
+      load: data.load || [],
+      clock: data.clock || [],
+      power: data.power || [],
+      note: 'Real CPU core temperature with load/clock/power. Requires admin privileges.'
+    };
+    if (verbose) result.errors = errors;
+    return result;
+  } catch (e) {
+    errors.push(`openHardwareService: ${e.message}`);
+    if (verbose) console.error(`[layer openHardwareService] failed: ${e.message}`);
+  }
+
+  // 第二层：性能计数器（热区温度，免管理员）
+  try {
+    const data = await readPerfCounterTemp();
+    const result = {
+      source: 'performance_counter',
+      isCoreTemp: false,
+      cpuName: null,
+      temperature: {
+        cores: [],
+        package: data.maxZone,
+        maxCore: data.maxZone,
+        zones: data.zones
+      },
+      load: [],
+      clock: [],
+      power: [],
+      note: 'ACPI thermal zone temperature (near CPU socket), NOT core temperature. No admin required.'
+    };
+    if (verbose) result.errors = errors;
+    return result;
+  } catch (e) {
+    errors.push(`performance_counter: ${e.message}`);
+    if (verbose) console.error(`[layer performance_counter] failed: ${e.message}`);
+  }
+
+  const err = new Error(`All layers failed:\n${errors.join('\n')}`);
+  err.errors = errors;
+  throw err;
+}
+
+/**
+ * 获取所有硬件的完整传感器信息（需管理员）
+ */
+async function getAllHardwareInfo(options = {}) {
+  const data = await readAllHardware();
+  return {
+    source: 'openHardwareService',
+    timestamp: data.timestamp,
+    hardware: data.hardware,
+    note: 'Full hardware sensor data. Requires admin privileges.'
+  };
+}
+
+/**
+ * 获取全部系统信息（一次性汇总）
+ * 并行获取所有模块，单个模块失败不影响其他
+ *
+ * @param {Object} options
+ * @param {boolean} options.includeProcesses - 是否包含进程列表，默认 false
+ * @param {boolean} options.includeServices - 是否包含服务列表，默认 false
+ * @param {boolean} options.includeOhmHardware - 是否包含 OHM 全硬件传感器（需管理员），默认 false
+ * @param {number} options.processTop - 进程前 N 个，默认 20
+ * @returns {Promise<Object>}
+ */
+async function getAllInfo(options = {}) {
+  const includeProcesses = options.includeProcesses || false;
+  const includeServices = options.includeServices || false;
+  const includeOhmHardware = options.includeOhmHardware || false;
+  const processTop = options.processTop || 20;
+
+  const tasks = {
+    system: getSystemInfo(),
+    cpu: getCpuTemp(),
+    memory: getMemoryInfo(),
+    disk: getDiskInfo(),
+    network: getNetworkInfo(),
+    battery: getBatteryInfo(),
+    gpu: getGpuInfo(),
+    usb: getUsbInfo()
+  };
+
+  if (includeProcesses) {
+    tasks.processes = getProcesses({ top: processTop, sortBy: 'memory' });
+  }
+  if (includeServices) {
+    tasks.services = getServicesInfo();
+  }
+  if (includeOhmHardware) {
+    tasks.ohmHardware = getAllHardwareInfo();
+  }
+
+  const entries = Object.entries(tasks);
+  const results = await Promise.allSettled(entries.map(([, p]) => p));
+
+  const info = {};
+  const errors = {};
+  entries.forEach(([key], i) => {
+    if (results[i].status === 'fulfilled') {
+      info[key] = results[i].value;
+    } else {
+      info[key] = null;
+      errors[key] = results[i].reason?.message || 'Unknown error';
+    }
+  });
+
+  return {
+    timestamp: new Date().toISOString(),
+    ...info,
+    errors: Object.keys(errors).length > 0 ? errors : null
+  };
+}
+
+module.exports = {
+  // CPU 温度（原有）
+  getCpuTemp,
+  getAllHardwareInfo,
+  createCpuTempDaemon,
+  CpuTempDaemon,
+  createCpuTempMonitor,
+  CpuTempMonitor,
+  // 系统信息（新增）
+  getSystemInfo,
+  getMemoryInfo,
+  getDiskInfo,
+  getNetworkInfo,
+  getBatteryInfo,
+  getGpuInfo,
+  getServicesInfo,
+  getUsbInfo,
+  getProcesses,
+  getAllInfo,
+  getPublicIp,
+  createSysInfoDaemon,
+  SysInfoDaemon,
+  // 进程操作
+  killProcess,
+  showItemInFolder,
+  findPidsByPort,
+  findPidsByName,
+  // 磁盘插拔监听
+  createDiskWatcher,
+  listDriveLetters,
+  // 进程图标
+  getProcessIcon,
+  getProcessIcons,
+  // 统一常驻服务
+  createHardwareService,
+  HardwareService,
+  // 后端资源占用
+  getBackendUsage
+};

package/lib/allhardware.js

@@ -0,0 +1,35 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+const SCRIPT = path.join(__dirname, '..', 'scripts', 'get-all-hardware.ps1');
+
+function readAllHardware() {
+  return new Promise((resolve, reject) => {
+    const ps = spawn('powershell', [
+      '-NoProfile',
+      '-ExecutionPolicy', 'Bypass',
+      '-File', SCRIPT
+    ]);
+
+    let out = '';
+    let err = '';
+    ps.stdout.on('data', d => (out += d));
+    ps.stderr.on('data', d => (err += d));
+    ps.on('close', code => {
+      if (code !== 0) {
+        return reject(new Error(`AllHardware exited ${code}: ${err || out}`));
+      }
+      try {
+        const data = JSON.parse(out.trim());
+        if (!data.hardware || data.hardware.length === 0) {
+          return reject(new Error('AllHardware: no hardware found'));
+        }
+        resolve(data);
+      } catch (e) {
+        reject(new Error(`AllHardware parse error: ${e.message}`));
+      }
+    });
+  });
+}
+
+module.exports = { readAllHardware };

package/lib/backend-usage.js

@@ -0,0 +1,103 @@
+/**
+ * backend-usage.js — 获取当前后端服务（Node.js + 所有子进程）的内存和 CPU 占用
+ *
+ * 性能：同步调用，~5-10ms（只枚举当前进程树，不遍历全部进程）
+ * 高频友好：进程内 koffi 调用，无子进程开销
+ *
+ * 返回结构：
+ *   {
+ *     timestamp, node: { pid, memory: {...}, cpuPercent, threads },
+ *     children: [{ pid, name, memoryMB, cpuPercent, threads, exePath }],
+ *     total: { processCount, memoryMB, cpuPercent, threads }
+ *   }
+ */
+
+const { sampleProcesses, computeCpuPercent } = require('./win32-procs');
+
+/**
+ * 递归查找进程树中的所有后代 PID
+ * @param {number} rootPid - 根进程 PID
+ * @param {Array} allProcs - sampleProcesses() 的全量结果
+ * @returns {Set<number>} 所有后代 PID（不含根进程）
+ */
+function findDescendantPids(rootPid, allProcs) {
+  const descendants = new Set();
+  const queue = [rootPid];
+  while (queue.length) {
+    const current = queue.shift();
+    for (const p of allProcs) {
+      if (p.parentPid === current && p.pid !== current && !descendants.has(p.pid)) {
+        descendants.add(p.pid);
+        queue.push(p.pid);
+      }
+    }
+  }
+  return descendants;
+}
+
+/**
+ * 获取后端服务资源占用（同步，高频安全）
+ * @returns {Object} 占用信息
+ */
+function getBackendUsage() {
+  const nodePid = process.pid;
+  const allProcs = sampleProcesses();
+  const cpuMap = computeCpuPercent(allProcs);
+
+  // 找到 Node.js 进程本身
+  const nodeProc = allProcs.find((p) => p.pid === nodePid);
+
+  // 递归找到所有子进程
+  const childPids = findDescendantPids(nodePid, allProcs);
+  const childProcs = allProcs.filter((p) => childPids.has(p.pid));
+
+  // Node.js 详细内存（process.memoryUsage）
+  const nodeMem = process.memoryUsage();
+
+  const nodeMemoryMB = nodeProc ? nodeProc.workingSet / 1024 / 1024 : nodeMem.rss / 1024 / 1024;
+  const nodeCpuPercent = cpuMap.get(nodePid) || 0;
+
+  // 子进程列表
+  const children = childProcs.map((p) => ({
+    pid: p.pid,
+    name: p.name,
+    memoryMB: Math.round((p.workingSet / 1024 / 1024) * 10) / 10,
+    privateMB: Math.round((p.privateUsage / 1024 / 1024) * 10) / 10,
+    cpuPercent: Math.round((cpuMap.get(p.pid) || 0) * 10) / 10,
+    threads: p.threads,
+    exePath: p.exePath || ''
+  }));
+
+  // 汇总
+  const totalMemoryMB = Math.round((nodeMemoryMB + children.reduce((s, c) => s + c.memoryMB, 0)) * 10) / 10;
+  const totalCpuPercent = Math.round((nodeCpuPercent + children.reduce((s, c) => s + c.cpuPercent, 0)) * 10) / 10;
+  const totalThreads = (nodeProc?.threads || 0) + children.reduce((s, c) => s + c.threads, 0);
+
+  return {
+    timestamp: Date.now(),
+    node: {
+      pid: nodePid,
+      name: 'node',
+      memory: {
+        rss: Math.round(nodeMem.rss),
+        rssMB: Math.round((nodeMem.rss / 1024 / 1024) * 10) / 10,
+        heapTotalMB: Math.round((nodeMem.heapTotal / 1024 / 1024) * 10) / 10,
+        heapUsedMB: Math.round((nodeMem.heapUsed / 1024 / 1024) * 10) / 10,
+        externalMB: Math.round((nodeMem.external / 1024 / 1024) * 10) / 10,
+        workingSetMB: Math.round(nodeMemoryMB * 10) / 10,
+        privateMB: nodeProc ? Math.round((nodeProc.privateUsage / 1024 / 1024) * 10) / 10 : 0
+      },
+      cpuPercent: Math.round(nodeCpuPercent * 10) / 10,
+      threads: nodeProc?.threads || 0
+    },
+    children,
+    total: {
+      processCount: 1 + children.length,
+      memoryMB: totalMemoryMB,
+      cpuPercent: totalCpuPercent,
+      threads: totalThreads
+    }
+  };
+}
+
+module.exports = { getBackendUsage };

package/lib/battery.js

@@ -0,0 +1,76 @@
+const { runPsJson } = require('./ps');
+
+/**
+ * 获取电池信息：健康度、充电状态、容量、电源计划
+ */
+async function getBatteryInfo() {
+  const cmd = `
+$batteries = Get-CimInstance Win32_Battery
+$portable = Get-CimInstance Win32_PortableBattery
+$powerPlan = powercfg /getactivescheme | ForEach-Object { ($_ -replace '.*\\(|\\).*', '') }
+
+if (-not $batteries -or $batteries.Count -eq 0) {
+  [PSCustomObject]@{
+    hasBattery = $false
+    batteries = @()
+    powerPlan = $powerPlan
+  } | ConvertTo-Json -Depth 5 -Compress
+  exit
+}
+
+$batteryList = @()
+foreach ($b in $batteries) {
+  $p = $portable | Where-Object { $_.DeviceID -eq $b.DeviceID } | Select-Object -First 1
+
+  $designCapacity = if ($p -and $p.DesignCapacity) { $p.DesignCapacity } else { $null }
+  $fullChargeCapacity = if ($p -and $p.FullChargeCapacity) { $p.FullChargeCapacity } else { $null }
+  $healthPercent = if ($designCapacity -and $fullChargeCapacity -and $designCapacity -gt 0) {
+    [math]::Round(($fullChargeCapacity / $designCapacity) * 100, 2)
+  } else { $null }
+
+  $batteryList += [PSCustomObject]@{
+    name = $b.Name
+    deviceId = $b.DeviceID
+    status = $b.Status
+    availability = $b.Availability
+    batteryStatusValue = $b.BatteryStatus
+    batteryStatus = switch ($b.BatteryStatus) {
+      1 { 'Discharging' }
+      2 { 'AC Power (not charging)' }
+      3 { 'Fully Charged' }
+      4 { 'Low' }
+      5 { 'Critical' }
+      6 { 'Charging' }
+      7 { 'Charging and High' }
+      8 { 'Charging and Low' }
+      9 { 'Charging and Critical' }
+      10 { 'Undefined' }
+      11 { 'Partially Charged' }
+      default { 'Unknown' }
+    }
+    chargePercent = $b.EstimatedChargeRemaining
+    estimatedRunTimeMinutes = if ($b.EstimatedRunTime -lt 10000) { $b.EstimatedRunTime } else { $null }
+    voltagemV = $b.DesignVoltage
+    designCapacitymWh = $designCapacity
+    fullChargeCapacitymWh = $fullChargeCapacity
+    healthPercent = $healthPercent
+    cycleCount = if ($p) { $p.CycleCount } else { $null }
+    manufacturer = if ($p) { $p.Manufacturer } else { $null }
+    manufactureDate = if ($p -and $p.ManufactureDate) { $p.ManufactureDate.ToString('o') } else { $null }
+    serialNumber = if ($p) { $p.SerialNumber } else { $null }
+    chemistry = if ($p) { $p.Chemistry } else { $null }
+  }
+}
+
+[PSCustomObject]@{
+  hasBattery = $true
+  batteries = $batteryList
+  powerPlan = $powerPlan
+  isCharging = @($batteryList | Where-Object { $_.batteryStatusValue -in 6,7,8,9 }).Count -gt 0
+  overallChargePercent = ($batteryList | Measure-Object -Property chargePercent -Average).Average
+} | ConvertTo-Json -Depth 5 -Compress
+`;
+  return runPsJson(cmd);
+}
+
+module.exports = { getBatteryInfo };

package/lib/disk-watcher.js

@@ -0,0 +1,156 @@
+/**
+ * disk-watcher.js — 磁盘插拔监听
+ *
+ * 双模式：
+ *   1. WMI 事件监听（Win32_VolumeChangeEvent）— 插拔瞬间触发，几乎零延迟
+ *   2. 低频轮询兜底（默认 5s）— 防止 WMI 事件丢失，同时校准当前盘符列表
+ *
+ * 用法：
+ *   const watcher = createDiskWatcher();
+ *   watcher.on('change', ({ added, removed, disks }) => { ... });
+ *   watcher.start();
+ *   watcher.stop();
+ */
+
+const { EventEmitter } = require('events');
+const { existsSync } = require('fs');
+const { spawn } = require('child_process');
+const path = require('path');
+
+const ALL_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+
+function listDriveLetters() {
+  return ALL_LETTERS.filter((l) => {
+    try { return existsSync(`${l}:/`); } catch { return false; }
+  });
+}
+
+// WMI 事件监听脚本：注册 Win32_VolumeChangeEvent，有事件时输出一行 JSON
+// EventType: 2=插入, 3=拔出  DriveName: 盘符如 "D:"
+const WMI_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+Register-CimIndicationEvent -ClassName Win32_VolumeChangeEvent -SourceIdentifier DiskChange | Out-Null
+Write-Output 'READY'
+while ($true) {
+  $e = Wait-Event -SourceIdentifier DiskChange -Timeout 1
+  if ($e) {
+    try {
+      $evt = $e.SourceEventArgs.NewEvent
+      if ($evt.EventType -eq 2 -or $evt.EventType -eq 3) {
+        $drive = ($evt.DriveName -replace ':$', '').ToUpper()
+        $obj = @{ type = $(if ($evt.EventType -eq 2) { 'add' } else { 'remove' }); drive = $drive }
+        Write-Output (ConvertTo-Json -InputObject $obj -Compress)
+      }
+    } catch { }
+    Remove-Event -SourceIdentifier DiskChange -ErrorAction SilentlyContinue
+  }
+}
+`;
+
+function createDiskWatcher(options = {}) {
+  const pollInterval = options.pollInterval || 5000;  // 兜底轮询间隔
+  const emitter = new EventEmitter();
+  let current = listDriveLetters();
+  let pollTimer = null;
+  let wmiChild = null;
+  let wmiBuf = '';
+  let started = false;
+
+  // 根据 WMI 事件计算 added/removed
+  function handleWmiEvent(evt) {
+    try {
+      const now = listDriveLetters();
+      const nowSet = new Set(now);
+      const curSet = new Set(current);
+      const added = now.filter((d) => !curSet.has(d));
+      const removed = current.filter((d) => !nowSet.has(d));
+      // 如果 WMI 报告的盘符不在计算结果里，手动加上
+      if (evt.type === 'add' && !added.includes(evt.drive) && nowSet.has(evt.drive)) {
+        added.push(evt.drive);
+      }
+      if (evt.type === 'remove' && !removed.includes(evt.drive) && !nowSet.has(evt.drive)) {
+        removed.push(evt.drive);
+      }
+      if (added.length || removed.length) {
+        current = now;
+        emitter.emit('change', { added, removed, disks: now });
+      }
+    } catch (e) { /* 忽略 */ }
+  }
+
+  // 兜底轮询：校准盘符列表，发现 WMI 漏掉的变化
+  function pollTick() {
+    try {
+      const now = listDriveLetters();
+      const nowSet = new Set(now);
+      const curSet = new Set(current);
+      const added = now.filter((d) => !curSet.has(d));
+      const removed = current.filter((d) => !nowSet.has(d));
+      if (added.length || removed.length) {
+        current = now;
+        emitter.emit('change', { added, removed, disks: now });
+      }
+    } catch (e) { /* 忽略 */ }
+  }
+
+  // 启动 WMI 事件监听子进程
+  function startWmiListener() {
+    if (process.platform !== 'win32') return;
+    const psExe = path.join(
+      process.env.SystemRoot || 'C:\\Windows',
+      'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'
+    );
+    wmiBuf = '';
+    wmiChild = spawn(psExe, ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', WMI_SCRIPT], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true
+    });
+    wmiChild.stdout.setEncoding('utf8');
+    wmiChild.stdout.on('data', (chunk) => {
+      wmiBuf += chunk;
+      let idx;
+      while ((idx = wmiBuf.indexOf('\n')) >= 0) {
+        const line = wmiBuf.slice(0, idx).trim();
+        wmiBuf = wmiBuf.slice(idx + 1);
+        if (!line || line === 'READY') continue;
+        try {
+          const evt = JSON.parse(line);
+          if (evt.type && evt.drive) handleWmiEvent(evt);
+        } catch { /* 脏数据忽略 */ }
+      }
+    });
+    wmiChild.on('exit', () => {
+      wmiChild = null;
+      if (started) {
+        // 崩溃后 3 秒重启
+        setTimeout(startWmiListener, 3000);
+      }
+    });
+  }
+
+  emitter.start = function () {
+    if (started) return;
+    started = true;
+    current = listDriveLetters();
+    startWmiListener();
+    pollTimer = setInterval(pollTick, pollInterval);
+  };
+
+  emitter.stop = function () {
+    started = false;
+    if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
+    if (wmiChild) {
+      wmiChild.kill();
+      wmiChild = null;
+    }
+  };
+
+  emitter.getDisks = function () {
+    return [...current];
+  };
+
+  return emitter;
+}
+
+module.exports = { createDiskWatcher, listDriveLetters };

package/lib/disk.js

@@ -0,0 +1,77 @@
+const { runPsJson } = require('./ps');
+
+/**
+ * 获取硬盘详细信息：物理磁盘、分区、SMART、读写速度
+ */
+async function getDiskInfo() {
+  const cmd = `
+$disks = Get-CimInstance Win32_DiskDrive
+$logical = Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3"
+$partitions = Get-CimInstance Win32_DiskPartition
+
+# 物理磁盘读写性能
+$diskPerf = Get-CimInstance Win32_PerfFormattedData_PerfDisk_PhysicalDisk | Where-Object { $_.Name -ne '_Total' }
+
+$diskList = @()
+foreach ($d in $disks) {
+  $partitionsForDisk = $partitions | Where-Object { $_.DiskIndex -eq $d.Index }
+  $driveLetters = @()
+  foreach ($p in $partitionsForDisk) {
+    $ld = Get-CimInstance -Query "ASSOCIATORS OF {Win32_DiskPartition.DeviceID='$($p.DeviceID)'} WHERE AssocClass=Win32_LogicalDiskToPartition"
+    foreach ($l in $ld) { $driveLetters += $l.DeviceID }
+  }
+
+  $perf = $diskPerf | Where-Object { $_.Name -like "$($d.Index) *" } | Select-Object -First 1
+
+  $diskList += [PSCustomObject]@{
+    index = $d.Index
+    model = $d.Model
+    manufacturer = $d.Manufacturer
+    interfaceType = $d.InterfaceType
+    mediaType = $d.MediaType
+    serialNumber = if ($d.SerialNumber) { $d.SerialNumber.Trim() } else { $null }
+    firmwareRevision = $d.FirmwareRevision
+    sizeGB = [math]::Round($d.Size / 1GB, 2)
+    totalCylinders = $d.TotalCylinders
+    totalHeads = $d.TotalHeads
+    totalSectors = $d.TotalSectors
+    bytesPerSector = $d.BytesPerSector
+    partitions = $partitionsForDisk.Count
+    driveLetters = $driveLetters
+    readBytesPerSec = if ($perf) { $perf.DiskReadBytesPerSec } else { $null }
+    writeBytesPerSec = if ($perf) { $perf.DiskWriteBytesPerSec } else { $null }
+    readQueueLength = if ($perf) { $perf.AvgDiskReadQueueLength } else { $null }
+    writeQueueLength = if ($perf) { $perf.AvgDiskWriteQueueLength } else { $null }
+    percentActive = if ($perf) { $perf.PercentDiskTime } else { $null }
+  }
+}
+
+$partitionList = @()
+foreach ($ld in $logical) {
+  $sizeGB = [math]::Round($ld.Size / 1GB, 2)
+  $freeGB = [math]::Round($ld.FreeSpace / 1GB, 2)
+  $usedGB = [math]::Round($sizeGB - $freeGB, 2)
+  $partitionList += [PSCustomObject]@{
+    drive = $ld.DeviceID
+    volumeName = $ld.VolumeName
+    fileSystem = $ld.FileSystem
+    sizeGB = $sizeGB
+    usedGB = $usedGB
+    freeGB = $freeGB
+    usedPercent = if ($sizeGB -gt 0) { [math]::Round(($usedGB / $sizeGB) * 100, 2) } else { 0 }
+    volumeSerialNumber = $ld.VolumeSerialNumber
+    compressed = $ld.Compressed
+  }
+}
+
+[PSCustomObject]@{
+  physicalDisks = $diskList
+  logicalDrives = $partitionList
+  diskCount = $diskList.Count
+  totalSizeGB = [math]::Round(($diskList | Measure-Object -Property sizeGB -Sum).Sum, 2)
+} | ConvertTo-Json -Depth 6 -Compress
+`;
+  return runPsJson(cmd, { timeout: 20000 });
+}
+
+module.exports = { getDiskInfo };