@daimazun/hardware-info 1.0.0

package/lib/gpu.js

@@ -0,0 +1,70 @@
+const { runPsJson } = require('./ps');
+
+/**
+ * 获取显卡和显示器信息
+ */
+async function getGpuInfo() {
+  const cmd = `
+$gpus = Get-CimInstance Win32_VideoController
+$monitors = Get-CimInstance Win32_DesktopMonitor
+$desktop = Get-CimInstance Win32_Desktop | Select-Object -First 1
+
+$gpuList = @()
+foreach ($g in $gpus) {
+  $hasResolution = $g.CurrentHorizontalResolution -ne $null -and $g.CurrentHorizontalResolution -gt 0
+  $nameLower = $g.Name.ToLower()
+  $isVirtual = (-not $hasResolution) -or $nameLower -match 'idd|virtual|mirror|dummy|wddm|remote'
+  if ($hasResolution) {
+    $displayMode = "$($g.CurrentHorizontalResolution)x$($g.CurrentVerticalResolution)@$($g.CurrentRefreshRate)Hz"
+  } elseif ($isVirtual) {
+    $displayMode = 'Virtual Display'
+  } else {
+    $displayMode = 'No Active Output'
+  }
+  $gpuList += [PSCustomObject]@{
+    name = $g.Name
+    isVirtual = $isVirtual
+    displayMode = $displayMode
+    adapterCompatibility = $g.AdapterCompatibility
+    adapterRAMMB = if ($g.AdapterRAM) { [math]::Round($g.AdapterRAM / 1MB, 2) } else { $null }
+    driverVersion = $g.DriverVersion
+    driverDate = if ($g.DriverDate) { $g.DriverDate.ToString('o') } else { $null }
+    videoProcessor = $g.VideoProcessor
+    videoArchitecture = $g.VideoArchitecture
+    currentHorizontalResolution = $g.CurrentHorizontalResolution
+    currentVerticalResolution = $g.CurrentVerticalResolution
+    currentRefreshRate = $g.CurrentRefreshRate
+    currentBitsPerPixel = $g.CurrentBitsPerPixel
+    maxRefreshRate = $g.MaxRefreshRate
+    minRefreshRate = $g.MinRefreshRate
+    videoModeDescription = $g.VideoModeDescription
+    deviceId = $g.DeviceID
+    pnpDeviceId = $g.PNPDeviceID
+  }
+}
+
+$monitorList = @()
+foreach ($m in $monitors) {
+  $monitorList += [PSCustomObject]@{
+    name = $m.Name
+    monitorManufacturer = $m.MonitorManufacturer
+    monitorType = $m.MonitorType
+    screenHeight = $m.ScreenHeight
+    screenWidth = $m.ScreenWidth
+    deviceId = $m.DeviceID
+    pnpDeviceId = $m.PNPDeviceID
+  }
+}
+
+[PSCustomObject]@{
+  gpus = $gpuList
+  monitors = $monitorList
+  gpuCount = $gpuList.Count
+  monitorCount = $monitorList.Count
+  primaryResolution = ($gpuList | Where-Object { -not $_.isVirtual -and $_.currentHorizontalResolution } | Select-Object -First 1).displayMode
+} | ConvertTo-Json -Depth 5 -Compress
+`;
+  return runPsJson(cmd);
+}
+
+module.exports = { getGpuInfo };

package/lib/hardware-service.js

@@ -0,0 +1,284 @@
+/**
+ * hardware-service.js — 统一常驻监控器
+ *
+ * 一个入口整合所有常驻模块，对外统一调用，无需分别创建和管理：
+ *   - SysInfoDaemon     系统信息全模块（system/memory/disk/network/battery/gpu/usb/processes/services）
+ *   - CpuTempMonitor    CPU 温度自动采样（EventEmitter）
+ *   - 进程 CPU% 采样器  自动启停（getProcesses includeCpu）
+ *   - DiskWatcher       磁盘插拔监听（EventEmitter）
+ *   - 公网 IP           带 60s 缓存
+ *
+ * 用法：
+ *   const monitor = await createHardwareService();
+ *   const temp = monitor.getCpuTemp();        // 最新 CPU 温度（自动采样）
+ *   const mem = await monitor.getMemory();     // 系统信息
+ *   const procs = await monitor.getProcesses({ top: 10 });  // 进程（自动带 CPU%）
+ *   monitor.on('disk-change', ({ added }) => {
+ *   });  // 磁盘插拔事件
+ *   monitor.close();
+ */
+
+const { EventEmitter } = require('events');
+const { createSysInfoDaemon } = require('./sysinfo-daemon');
+const { createCpuTempMonitor } = require('./monitor');
+const { createCpuTempDaemon } = require('./ohm-daemon');
+const { createDiskWatcher } = require('./disk-watcher');
+const { getProcesses } = require('./processes');
+const { getPublicIp } = require('./public-ip');
+const { getBackendUsage } = require('./backend-usage');
+const { killProcess, showItemInFolder, findPidsByPort, findPidsByName } = require('./process-ops');
+
+class HardwareService extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this._started = false;
+    this._closed = false;
+
+    // 配置
+    this._cpuTempInterval = options.cpuTempInterval ?? 1000;
+    this._diskWatchInterval = options.diskWatchInterval ?? 2000;
+    this._enableCpuTemp = options.enableCpuTemp ?? true;
+    this._enableDiskWatcher = options.enableDiskWatcher ?? true;
+
+    // 子模块实例
+    this._sysInfo = null;
+    this._cpuTempMonitor = null;
+    this._diskWatcher = null;
+
+    // 最新 CPU 温度缓存
+    this._cpuTemp = null;
+  }
+
+  /**
+   * 启动所有子模块（createHardwareService 时自动调用）
+   */
+  async start() {
+    if (this._started || this._closed) return;
+    this._started = true;
+
+    // 1. SysInfoDaemon（系统信息全模块）
+    this._sysInfo = await createSysInfoDaemon({
+      systemCacheTtl: this.options.systemCacheTtl,
+      networkCacheTtl: this.options.networkCacheTtl,
+      maxRestarts: this.options.maxRestarts
+    });
+
+    // 2. CPU 温度自动采样（异步初始化，不阻塞启动；非管理员时降级可能较慢）
+    if (this._enableCpuTemp && this._cpuTempInterval > 0) {
+      this._initCpuTempMonitor();
+    }
+
+    // 3. 磁盘插拔监听
+    if (this._enableDiskWatcher) {
+      this._diskWatcher = createDiskWatcher({ interval: this._diskWatchInterval });
+      this._diskWatcher.on('change', (info) => {
+        this.emit('disk-change', info);
+      });
+      this._diskWatcher.start();
+    }
+  }
+
+  // ========== 系统信息（代理到 SysInfoDaemon） ==========
+
+  async getSystem() { return this._sysInfo.getSystem(); }
+  async getMemory() { return this._sysInfo.getMemory(); }
+  async getDisk() { return this._sysInfo.getDisk(); }
+  async getNetwork() { return this._sysInfo.getNetwork(); }
+  async getBattery() { return this._sysInfo.getBattery(); }
+  async getGpu() { return this._sysInfo.getGpu(); }
+  async getUsb() { return this._sysInfo.getUsb(); }
+  async getServices(options = {}) { return this._sysInfo.getServices(options); }
+  async getAll(options = {}) { return this._sysInfo.getAll(options); }
+
+  // ========== 进程（自动带 CPU%） ==========
+
+  /**
+   * 获取进程列表（默认 includeCpu=true，自动启动常驻采样器）
+   */
+  async getProcesses(options = {}) {
+    const opts = { includeCpu: true, ...options };
+    return getProcesses(opts);
+  }
+
+  // ========== CPU 温度 ==========
+
+  /**
+   * 异步初始化 CPU 温度监控器（不阻塞 start）
+   */
+  async _initCpuTempMonitor() {
+    try {
+      this._cpuTempMonitor = await createCpuTempMonitor({ interval: this._cpuTempInterval });
+      this._cpuTempMonitor.on('data', (data) => {
+        this._cpuTemp = data;
+        this.emit('cpu-temp', data);
+      });
+      this._cpuTempMonitor.on('error', (err) => {
+        this.emit('error', { source: 'cpu-temp', error: err });
+      });
+    } catch (e) {
+      this.emit('error', { source: 'cpu-temp-init', error: e });
+    }
+  }
+
+  /**
+   * 获取最新 CPU 温度（自动采样模式下同步返回，无需 await）
+   * @returns {object|null} 最新 CPU 温度数据，未采样到则返回 null
+   */
+  getCpuTemp() {
+    return this._cpuTemp;
+  }
+
+  /**
+   * 手动拉取一次 CPU 温度（cpuTempInterval=0 时用，或需要立即获取最新值）
+   */
+  async fetchCpuTemp() {
+    if (this._cpuTempMonitor && this._cpuTemp) {
+      // 自动采样模式下已有最新值
+      return this._cpuTemp;
+    }
+    // 未启用自动采样时，临时创建 Daemon 拉一次
+    const daemon = await createCpuTempDaemon();
+    try {
+      this._cpuTemp = await daemon.getTemp();
+      return this._cpuTemp;
+    } finally {
+      await daemon.close();
+    }
+  }
+
+  // ========== 公网 IP ==========
+
+  async getPublicIp(options = {}) {
+    return getPublicIp(options);
+  }
+
+  // ========== 磁盘 ==========
+
+  /**
+   * 获取当前所有盘符
+   */
+  getDisks() {
+    return this._diskWatcher ? this._diskWatcher.getDisks() : [];
+  }
+
+  // ========== 后端资源占用 ==========
+
+  /**
+   * 获取当前后端服务（Node.js + 所有子进程）的内存和 CPU 占用
+   * 同步，~5-10ms，高频安全
+   */
+  getBackendUsage() {
+    return getBackendUsage();
+  }
+
+  // ========== 进程操作 ==========
+
+  async killProcess(pid) {
+    return killProcess(pid);
+  }
+
+  showItemInFolder(filePath) {
+    return showItemInFolder(filePath);
+  }
+
+  /**
+   * 查找占用指定端口的进程 PID
+   * @param {number} port - 端口号
+   * @param {'tcp'|'udp'|'all'} [protocol='all']
+   * @returns {Promise<number[]>}
+   */
+  findPidsByPort(port, protocol) {
+    return findPidsByPort(port, protocol);
+  }
+
+  /**
+   * 按进程名查找 PID
+   * @param {string|string[]} name - 进程名或进程名数组
+   * @returns {number[]}
+   */
+  findPidsByName(name) {
+    return findPidsByName(name);
+  }
+
+  // ========== 控制 ==========
+
+  /**
+   * 暂停所有采样（保留状态，可 resume）
+   */
+  pause() {
+    if (this._cpuTempMonitor) this._cpuTempMonitor.stop();
+    if (this._diskWatcher) this._diskWatcher.stop();
+    this.emit('pause');
+  }
+
+  /**
+   * 恢复采样
+   */
+  resume() {
+    if (this._cpuTempMonitor) this._cpuTempMonitor.start();
+    if (this._diskWatcher) this._diskWatcher.start();
+    this.emit('resume');
+  }
+
+  /**
+   * 获取各子模块状态
+   */
+  getStatus() {
+    return {
+      started: this._started,
+      closed: this._closed,
+      sysInfoReady: !!this._sysInfo,
+      cpuTempEnabled: this._enableCpuTemp,
+      cpuTempRunning: !!(this._cpuTempMonitor && this._cpuTempMonitor.running),
+      cpuTempHasData: !!this._cpuTemp,
+      diskWatcherEnabled: this._enableDiskWatcher,
+      diskWatcherRunning: !!this._diskWatcher,
+      currentDisks: this.getDisks()
+    };
+  }
+
+  /**
+   * 关闭所有子模块，释放资源
+   */
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._started = false;
+
+    if (this._cpuTempMonitor) {
+      this._cpuTempMonitor.stop();
+      this._cpuTempMonitor = null;
+    }
+    if (this._diskWatcher) {
+      this._diskWatcher.stop();
+      this._diskWatcher = null;
+    }
+    if (this._sysInfo) {
+      await this._sysInfo.close();
+      this._sysInfo = null;
+    }
+    this._cpuTemp = null;
+    this.emit('close');
+    this.removeAllListeners();
+  }
+}
+
+/**
+ * 创建统一常驻监控器（自动启动）
+ * @param {Object} options
+ * @param {number} options.cpuTempInterval - CPU 温度采样间隔 ms，默认 1000，设 0 不自动采样
+ * @param {number} options.diskWatchInterval - 磁盘监听间隔 ms，默认 2000
+ * @param {number} options.systemCacheTtl - system 缓存 TTL ms，默认 30000
+ * @param {number} options.networkCacheTtl - 网卡配置缓存 TTL ms，默认 30000
+ * @param {boolean} options.enableCpuTemp - 是否启用 CPU 温度，默认 true
+ * @param {boolean} options.enableDiskWatcher - 是否启用磁盘监听，默认 true
+ * @returns {Promise<HardwareService>}
+ */
+async function createHardwareService(options = {}) {
+  const monitor = new HardwareService(options);
+  await monitor.start();
+  return monitor;
+}
+
+module.exports = { createHardwareService, HardwareService };

package/lib/memory.js

@@ -0,0 +1,59 @@
+const { runPsJson } = require('./ps');
+
+/**
+ * 获取内存详细信息：物理内存条（型号/频率/时序）、内存阵列、使用情况
+ */
+async function getMemoryInfo() {
+  const cmd = `
+$sticks = Get-CimInstance Win32_PhysicalMemory
+$array = Get-CimInstance Win32_PhysicalMemoryArray | Select-Object -First 1
+$os = Get-CimInstance Win32_OperatingSystem
+
+$stickList = @()
+foreach ($s in $sticks) {
+  $stickList += [PSCustomObject]@{
+    deviceLocator = $s.DeviceLocator
+    bankLabel = $s.BankLabel
+    capacityGB = [math]::Round($s.Capacity / 1GB, 2)
+    speedMHz = $s.Speed
+    configuredSpeedMHz = $s.ConfiguredClockSpeed
+    memoryType = if ($s.MemoryType) { $s.MemoryType } else { $null }
+    typeDetail = $s.TypeDetail
+    manufacturer = $s.Manufacturer
+    partNumber = $s.PartNumber.Trim()
+    serialNumber = $s.SerialNumber
+    dataWidth = $s.DataWidth
+    totalWidth = $s.TotalWidth
+  }
+}
+
+$totalPhysicalGB = [math]::Round($os.TotalVisibleMemorySize / 1MB, 2)
+$freePhysicalGB = [math]::Round($os.FreePhysicalMemory / 1MB, 2)
+$usedPhysicalGB = [math]::Round($totalPhysicalGB - $freePhysicalGB, 2)
+
+$totalVirtualGB = [math]::Round($os.TotalVirtualMemorySize / 1MB, 2)
+$freeVirtualGB = [math]::Round($os.FreeVirtualMemory / 1MB, 2)
+
+[PSCustomObject]@{
+  totalPhysicalGB = $totalPhysicalGB
+  usedPhysicalGB = $usedPhysicalGB
+  freePhysicalGB = $freePhysicalGB
+  usedPercent = [math]::Round(($usedPhysicalGB / $totalPhysicalGB) * 100, 2)
+  totalVirtualGB = $totalVirtualGB
+  freeVirtualGB = $freeVirtualGB
+  sticks = $stickList
+  stickCount = $stickList.Count
+  array = if ($array) {
+    [PSCustomObject]@{
+      maxCapacityGB = [math]::Round($array.MaxCapacity / 1MB, 2)
+      memoryDevices = $array.MemoryDevices
+      use = $array.Use
+      location = $array.Location
+    }
+  } else { $null }
+} | ConvertTo-Json -Depth 5 -Compress
+`;
+  return runPsJson(cmd);
+}
+
+module.exports = { getMemoryInfo };

package/lib/monitor.js

@@ -0,0 +1,176 @@
+const EventEmitter = require('events');
+const { createCpuTempDaemon } = require('./ohm-daemon');
+
+/**
+ * CPU 温度高频监控器
+ * 基于常驻进程模式，定时轮询并通过事件推送数据
+ *
+ * 事件:
+ *   'start'   - 监控启动
+ *   'data'    - 每次读取到数据 (data)
+ *   'error'   - 读取出错 (error)
+ *   'pause'   - 已暂停
+ *   'resume'  - 已恢复
+ *   'stop'    - 监控停止
+ */
+class CpuTempMonitor extends EventEmitter {
+  /**
+   * @param {Object} options
+   * @param {number} options.interval - 轮询间隔（毫秒），默认 1000
+   * @param {number} options.maxRestarts - 常驻进程最大重启次数，默认 3
+   * @param {boolean} options.verbose - 是否输出详细日志
+   */
+  constructor(options = {}) {
+    super();
+    this.interval = options.interval || 1000;
+    this.maxRestarts = options.maxRestarts || 3;
+    this.verbose = options.verbose || false;
+
+    this.daemon = null;
+    this.timer = null;
+    this.running = false;
+    this.paused = false;
+    this.lastData = null;
+    this._reading = false;
+  }
+
+  /**
+   * 启动监控
+   */
+  async start() {
+    if (this.running) return;
+
+    this.daemon = await createCpuTempDaemon({
+      maxRestarts: this.maxRestarts,
+      verbose: this.verbose
+    });
+
+    this.running = true;
+    this.paused = false;
+    this.emit('start');
+    this._scheduleNext();
+  }
+
+  /**
+   * 立即读取一次（不等待下一个轮询周期）
+   */
+  async readNow() {
+    if (!this.daemon) throw new Error('Monitor not started');
+    const data = await this.daemon.getCpuTemp();
+    this.lastData = data;
+    this.emit('data', data);
+    return data;
+  }
+
+  /**
+   * 动态调整轮询间隔
+   * @param {number} ms - 新的间隔（毫秒）
+   */
+  setInterval(ms) {
+    if (typeof ms !== 'number' || ms < 10) {
+      throw new Error('Interval must be >= 10ms');
+    }
+    this.interval = ms;
+    if (this.verbose) console.log(`[monitor] interval changed to ${ms}ms`);
+  }
+
+  /**
+   * 暂停轮询（进程保持运行，不读数据）
+   */
+  pause() {
+    if (!this.running || this.paused) return;
+    this.paused = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.emit('pause');
+  }
+
+  /**
+   * 恢复轮询
+   */
+  resume() {
+    if (!this.running || !this.paused) return;
+    this.paused = false;
+    this.emit('resume');
+    this._scheduleNext();
+  }
+
+  /**
+   * 停止监控，关闭常驻进程
+   */
+  async stop() {
+    if (!this.running) return;
+
+    this.running = false;
+    this.paused = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    if (this.daemon) {
+      await this.daemon.close();
+      this.daemon = null;
+    }
+
+    this.emit('stop');
+  }
+
+  /**
+   * 获取最近一次数据
+   */
+  getLastData() {
+    return this.lastData;
+  }
+
+  /**
+   * 是否正在运行
+   */
+  isRunning() {
+    return this.running && !this.paused;
+  }
+
+  _scheduleNext() {
+    if (!this.running || this.paused) return;
+
+    this.timer = setTimeout(() => {
+      this._doRead();
+    }, this.interval);
+  }
+
+  async _doRead() {
+    if (!this.running || this.paused) return;
+    if (this._reading) {
+      // 上一次还没读完，跳过本次，避免堆积
+      this._scheduleNext();
+      return;
+    }
+
+    this._reading = true;
+    try {
+      const data = await this.daemon.getCpuTemp();
+      this.lastData = data;
+      this.emit('data', data);
+    } catch (e) {
+      this.emit('error', e);
+    } finally {
+      this._reading = false;
+      this._scheduleNext();
+    }
+  }
+}
+
+/**
+ * 创建并启动一个 CPU 温度监控器
+ * @param {Object} options - 同 CpuTempMonitor 构造参数
+ * @returns {Promise<CpuTempMonitor>}
+ */
+async function createCpuTempMonitor(options = {}) {
+  const monitor = new CpuTempMonitor(options);
+  await monitor.start();
+  return monitor;
+}
+
+module.exports = { CpuTempMonitor, createCpuTempMonitor };

package/lib/network.js

@@ -0,0 +1,75 @@
+const { runPsJson } = require('./ps');
+
+/**
+ * 获取网络信息：网卡、IP、实时网速、WiFi
+ */
+async function getNetworkInfo() {
+  const cmd = `
+$adapters = Get-CimInstance Win32_NetworkAdapter | Where-Object { $_.PhysicalAdapter -eq $true -or $_.NetConnectionID }
+$configs = Get-CimInstance Win32_NetworkAdapterConfiguration | Where-Object { $_.IPEnabled }
+$ifStats = Get-CimInstance Win32_PerfFormattedData_Tcpip_NetworkInterface
+
+# WiFi 信息
+$wifi = $null
+try {
+  $wlan = netsh wlan show interfaces 2>$null
+  if ($wlan -match 'SSID') {
+    $ssid = ($wlan | Select-String 'SSID' | Select-Object -First 1).ToString() -replace '.*:\s*', ''
+    $signal = ($wlan | Select-String 'Signal' | Select-Object -First 1).ToString() -replace '.*:\s*', '' -replace '%', ''
+    $channel = ($wlan | Select-String 'Channel' | Select-Object -First 1).ToString() -replace '.*:\s*', ''
+    $wifi = [PSCustomObject]@{
+      ssId = $ssid.Trim()
+      signalPercent = if ($signal) { [int]$signal.Trim() } else { $null }
+      channel = if ($channel) { [int]$channel.Trim() } else { $null }
+    }
+  }
+} catch {}
+
+$adapterList = @()
+foreach ($a in $adapters) {
+  $cfg = $configs | Where-Object { $_.Index -eq $a.Index } | Select-Object -First 1
+  # 性能计数器会把网卡名中的圆括号替换成方括号，如 Intel(R) -> Intel[R]
+  $counterName = $a.Name -replace '\(', '[' -replace '\)', ']'
+  $stat = $ifStats | Where-Object { $_.Name -eq $a.NetConnectionID -or $_.Name -eq $counterName -or $_.Name -like "*$counterName*" } | Select-Object -First 1
+
+  $adapterList += [PSCustomObject]@{
+    name = $a.Name
+    connectionName = $a.NetConnectionID
+    description = $a.Description
+    manufacturer = $a.Manufacturer
+    macAddress = $a.MACAddress
+    adapterType = $a.AdapterType
+    speedMbps = if ($a.Speed) { [math]::Round($a.Speed / 1MB, 0) } else { $null }
+    status = $a.NetConnectionStatus
+    isPhysical = $a.PhysicalAdapter
+    interfaceIndex = $a.InterfaceIndex
+    ipAddresses = if ($cfg) { $cfg.IPAddress } else { @() }
+    ipSubnets = if ($cfg) { $cfg.IPSubnet } else { @() }
+    defaultIpGateway = if ($cfg) { $cfg.DefaultIPGateway } else { @() }
+    dnsServers = if ($cfg) { $cfg.DNSServerSearchOrder } else { @() }
+    dhcpEnabled = if ($cfg) { $cfg.DHCPEnabled } else { $null }
+    dhcpServer = if ($cfg) { $cfg.DHCPServer } else { $null }
+    bytesReceivedPerSec = if ($stat) { $stat.BytesReceivedPerSec } else { $null }
+    bytesSentPerSec = if ($stat) { $stat.BytesSentPerSec } else { $null }
+    packetsReceivedPerSec = if ($stat) { $stat.PacketsReceivedPerSec } else { $null }
+    packetsSentPerSec = if ($stat) { $stat.PacketsSentPerSec } else { $null }
+    totalBytesReceived = if ($stat) { $stat.BytesTotalPersec } else { $null }
+  }
+}
+
+$activeAdapters = $adapterList | Where-Object { $_.status -eq 2 -and $_.ipAddresses.Count -gt 0 }
+
+[PSCustomObject]@{
+  adapters = $adapterList
+  activeAdapters = $activeAdapters
+  adapterCount = $adapterList.Count
+  activeAdapterCount = @($activeAdapters).Count
+  wifi = $wifi
+  totalDownloadBytesPerSec = ($activeAdapters | Measure-Object -Property bytesReceivedPerSec -Sum).Sum
+  totalUploadBytesPerSec = ($activeAdapters | Measure-Object -Property bytesSentPerSec -Sum).Sum
+} | ConvertTo-Json -Depth 6 -Compress
+`;
+  return runPsJson(cmd, { timeout: 15000 });
+}
+
+module.exports = { getNetworkInfo };