@daimazun/hardware-info 1.0.0

package/lib/processes.js

@@ -0,0 +1,232 @@
+/**
+ * processes.js — 进程列表获取
+ *
+ * 双后端：
+ *   - koffi（默认）：直调 Win32 API，264进程 ~25ms，支持实时 CPU%
+ *   - wmi：PowerShell Get-Process，~115ms，命令行信息更全
+ *
+ * 高频优化：
+ *   - includeCpu=true 时启动 1s 常驻采样器，自动维护 CPU% 基线
+ *   - 采样器空闲 15s 自动停止，不浪费 CPU
+ *   - getProcesses 读缓存毫秒级返回
+ */
+
+const { runPsJson } = require('./ps');
+const { sampleProcesses, computeCpuPercent, resetCpuBaseline, getInstallTime } = require('./win32-procs');
+const { totalmem } = require('os');
+
+// ---- 常驻采样器（用于 CPU%）----
+let processCache = [];
+let processTimer = null;
+let lastRequestAt = 0;
+const IDLE_MS = 15000;
+
+function tickProcessSampler() {
+  try {
+    const raw = sampleProcesses();
+    const cpuMap = computeCpuPercent(raw);
+    processCache = raw.map((p) => ({
+      pid: p.pid,
+      name: p.name.replace(/\.exe$/i, ''),
+      threads: p.threads,
+      parentPid: p.parentPid,
+      memoryMB: Math.round((p.workingSet / 1048576) * 100) / 100,
+      memoryPrivateMB: Math.round((p.privateUsage / 1048576) * 100) / 100,
+      cpuPercent: Math.max(0, Math.round((cpuMap.get(p.pid) || 0) * 10) / 10),
+      exePath: p.exePath,
+      installTime: ''
+    }));
+  } catch (e) {
+    // 采样失败保留上一帧
+  }
+}
+
+function ensureProcessSampler() {
+  lastRequestAt = Date.now();
+  if (processTimer) return;
+  // 立即采一帧（第一帧 CPU% 为 0，建立基线；第二帧起正常）
+  tickProcessSampler();
+  processTimer = setInterval(tickProcessSampler, 1000);
+  // 空闲自停检查
+  const idleChecker = setInterval(() => {
+    if (processTimer && Date.now() - lastRequestAt > IDLE_MS) {
+      stopProcessSampler();
+      clearInterval(idleChecker);
+    }
+  }, 5000);
+}
+
+function stopProcessSampler() {
+  if (processTimer) {
+    clearInterval(processTimer);
+    processTimer = null;
+  }
+  resetCpuBaseline();
+}
+
+// ---- 按名称聚合 ----
+function groupByName(procs) {
+  const groups = new Map();
+  for (const p of procs) {
+    const key = p.name;
+    if (!groups.has(key)) {
+      groups.set(key, {
+        name: key,
+        pid: p.pid,
+        pids: [p.pid],
+        memoryMB: 0,
+        memoryPrivateMB: 0,
+        cpuPercent: 0,
+        threads: 0,
+        exePath: p.exePath,
+        installTime: p.installTime,
+        instances: []
+      });
+    }
+    const g = groups.get(key);
+    g.memoryMB += p.memoryMB;
+    g.memoryPrivateMB += p.memoryPrivateMB;
+    g.cpuPercent = Math.max(g.cpuPercent, p.cpuPercent || 0);
+    g.threads += p.threads;
+    g.pids.push(p.pid);
+    g.instances.push(p);
+    // 主进程取内存最大的
+    if (p.memoryMB > g.memoryMB) {
+      g.pid = p.pid;
+      g.exePath = p.exePath;
+      g.installTime = p.installTime;
+    }
+  }
+  return Array.from(groups.values()).map((g) => ({
+    ...g,
+    memoryMB: Math.round(g.memoryMB * 100) / 100,
+    memoryPrivateMB: Math.round(g.memoryPrivateMB * 100) / 100,
+    percent: Math.round((g.memoryMB / (totalmem() / 1048576)) * 1000) / 10
+  }));
+}
+
+// ---- koffi 后端 ----
+function getProcessesKoffi(options = {}) {
+  const { top = 0, sortBy = 'memory', includeCpu = false, groupByName: group = false, includeInstallTime = false } = options;
+
+  let procs;
+  if (includeCpu) {
+    ensureProcessSampler();
+    procs = processCache.map((p) => ({ ...p }));
+  } else {
+    const raw = sampleProcesses();
+    procs = raw.map((p) => ({
+      pid: p.pid,
+      name: p.name.replace(/\.exe$/i, ''),
+      threads: p.threads,
+      parentPid: p.parentPid,
+      memoryMB: Math.round((p.workingSet / 1048576) * 100) / 100,
+      memoryPrivateMB: Math.round((p.privateUsage / 1048576) * 100) / 100,
+      cpuPercent: 0,
+      exePath: p.exePath,
+      installTime: ''
+    }));
+  }
+
+  // 安装时间（按需，fs.statSync 毫秒级但全量遍历有开销）
+  if (includeInstallTime) {
+    for (const p of procs) {
+      if (p.exePath) p.installTime = getInstallTime(p.exePath);
+    }
+  }
+
+  // 按名称聚合
+  if (group) {
+    procs = groupByName(procs);
+  }
+
+  // 排序
+  if (sortBy === 'cpu') {
+    procs.sort((a, b) => (b.cpuPercent || 0) - (a.cpuPercent || 0));
+  } else if (sortBy === 'name') {
+    procs.sort((a, b) => a.name.localeCompare(b.name));
+  } else {
+    procs.sort((a, b) => b.memoryMB - a.memoryMB);
+  }
+
+  const total = procs.length;
+  if (top > 0) procs = procs.slice(0, top);
+
+  return { total, returned: procs.length, processes: procs, backend: 'koffi' };
+}
+
+// ---- WMI 后端（兼容，命令行更全）----
+async function getProcessesWmi(options = {}) {
+  const top = options.top || 0;
+  const sortBy = options.sortBy || 'memory';
+  const includeCommandLine = options.includeCommandLine || false;
+
+  let sortProperty = 'WorkingSet64';
+  if (sortBy === 'cpu') sortProperty = 'CPU';
+  else if (sortBy === 'name') sortProperty = 'ProcessName';
+
+  const topClause = top > 0 ? ` | Select-Object -First ${top}` : '';
+
+  let cmdLineInit = '';
+  let cmdLineField = '$null';
+  if (includeCommandLine) {
+    cmdLineInit = `
+$wmiProcs = Get-CimInstance Win32_Process | Select-Object ProcessId, CommandLine
+$cmdLineMap = @{}
+foreach ($w in $wmiProcs) { $cmdLineMap[$w.ProcessId] = $w.CommandLine }
+`;
+    cmdLineField = 'if ($cmdLineMap.ContainsKey($p.Id)) { $cmdLineMap[$p.Id] } else { $null }';
+  }
+
+  const cmd = `
+$procs = Get-Process | Sort-Object -Property ${sortProperty} -Descending${topClause}
+${cmdLineInit}
+$list = @()
+foreach ($p in $procs) {
+  $list += [PSCustomObject]@{
+    pid = $p.Id
+    name = $p.ProcessName
+    cpuSeconds = if ($p.CPU) { [math]::Round($p.CPU, 2) } else { 0 }
+    memoryMB = [math]::Round($p.WorkingSet64 / 1MB, 2)
+    memoryPrivateMB = [math]::Round($p.PrivateMemorySize64 / 1MB, 2)
+    memoryVirtualMB = [math]::Round($p.VirtualMemorySize64 / 1MB, 2)
+    threads = $p.Threads.Count
+    handles = $p.HandleCount
+    startTime = if ($p.StartTime) { $p.StartTime.ToString('o') } else { $null }
+    path = $p.Path
+    company = $p.Company
+    fileVersion = $p.FileVersion
+    commandLine = ${cmdLineField}
+  }
+}
+[PSCustomObject]@{
+  total = (Get-Process).Count
+  returned = $list.Count
+  processes = $list
+  backend = 'wmi'
+} | ConvertTo-Json -Depth 4 -Compress
+`;
+
+  return runPsJson(cmd, { timeout: 20000 });
+}
+
+/**
+ * 获取进程列表
+ * @param {Object} options
+ * @param {number} options.top - 返回前 N 个，默认 0 表示全部
+ * @param {string} options.sortBy - 排序: 'memory' | 'cpu' | 'name'，默认 'memory'
+ * @param {string} options.backend - 'koffi'（默认，快）| 'wmi'（命令行全）
+ * @param {boolean} options.includeCpu - koffi 后端：是否计算实时 CPU%（启动常驻采样器）
+ * @param {boolean} options.groupByName - koffi 后端：是否按进程名聚合
+ * @param {boolean} options.includeInstallTime - koffi 后端：是否包含 exe 安装时间
+ * @param {boolean} options.includeCommandLine - wmi 后端：是否包含命令行
+ */
+async function getProcesses(options = {}) {
+  const backend = options.backend || 'koffi';
+  if (backend === 'wmi') {
+    return getProcessesWmi(options);
+  }
+  return getProcessesKoffi(options);
+}
+
+module.exports = { getProcesses, stopProcessSampler };

package/lib/ps.js

@@ -0,0 +1,93 @@
+const { spawn } = require('child_process');
+
+// UTF-8 编码前缀，解决中文 Windows PowerShell 默认 GBK 输出导致的乱码
+const UTF8_PREFIX = '[Console]::OutputEncoding=[System.Text.Encoding]::UTF8;$OutputEncoding=[System.Text.Encoding]::UTF8;chcp 65001>$null;';
+
+/**
+ * 执行 PowerShell 命令，返回解析后的 JSON
+ * @param {string} command - PowerShell 命令（输出必须是 JSON）
+ * @param {Object} options
+ * @param {number} options.timeout - 超时毫秒，默认 15000
+ * @returns {Promise<any>}
+ */
+function runPsJson(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const ps = spawn('powershell', [
+      '-NoProfile',
+      '-ExecutionPolicy', 'Bypass',
+      '-Command', UTF8_PREFIX + command
+    ], { timeout: options.timeout || 15000 });
+
+    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 && !out.trim()) {
+        return reject(new Error(`PowerShell exited ${code}: ${err || out}`));
+      }
+      try {
+        const trimmed = out.trim();
+        if (!trimmed) return resolve(null);
+        resolve(JSON.parse(trimmed));
+      } catch (e) {
+        reject(new Error(`Failed to parse PowerShell JSON: ${e.message}\nRaw output: ${out.slice(0, 500)}`));
+      }
+    });
+    ps.on('error', reject);
+  });
+}
+
+/**
+ * 执行 PowerShell 脚本文件，返回解析后的 JSON
+ * @param {string} scriptPath - 脚本路径
+ * @param {string[]} args - 参数
+ * @returns {Promise<any>}
+ */
+function runPsScript(scriptPath, args = []) {
+  return new Promise((resolve, reject) => {
+    // 用 -Command 方式执行，先设置 UTF-8 编码再 dot-source 脚本
+    const argStr = args.map(a => `"${a}"`).join(' ');
+    const command = `${UTF8_PREFIX}& "${scriptPath}" ${argStr}`;
+
+    const ps = spawn('powershell', [
+      '-NoProfile',
+      '-ExecutionPolicy', 'Bypass',
+      '-Command', command
+    ]);
+
+    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 && !out.trim()) {
+        return reject(new Error(`Script exited ${code}: ${err || out}`));
+      }
+      try {
+        const trimmed = out.trim();
+        if (!trimmed) return resolve(null);
+        resolve(JSON.parse(trimmed));
+      } catch (e) {
+        reject(new Error(`Failed to parse script JSON: ${e.message}\nRaw: ${out.slice(0, 500)}`));
+      }
+    });
+    ps.on('error', reject);
+  });
+}
+
+/**
+ * 把 CIM 查询结果转成 JSON 输出的 PowerShell 命令片段
+ * @param {string} cimClass - WMI/CIM 类名
+ * @param {string} namespace - 命名空间，默认 root/cimv2
+ * @param {string} filter - 过滤条件
+ * @returns {string}
+ */
+function cimToJson(cimClass, namespace = 'root/cimv2', filter = '') {
+  let cmd = `Get-CimInstance -ClassName ${cimClass} -Namespace "${namespace}"`;
+  if (filter) cmd += ` -Filter "${filter}"`;
+  cmd += ` | ConvertTo-Json -Depth 4 -Compress`;
+  return cmd;
+}
+
+module.exports = { runPsJson, runPsScript, cimToJson };

package/lib/public-ip.js

@@ -0,0 +1,124 @@
+/**
+ * 公网 IP 获取模块
+ * 主方式：DNS 查询（OpenDNS / Google DNS），比 HTTP 快 3-5 倍
+ * 兜底：HTTPS 多源（ifconfig.me / ipify / icanhazip）
+ * 零依赖 + 60 秒缓存
+ */
+const dns = require('dns');
+const https = require('https');
+
+// ========== DNS 查询方式 ==========
+
+const openDns = new dns.promises.Resolver({ timeout: 3000, tries: 1 });
+openDns.setServers(['208.67.222.222', '208.67.220.220']);
+
+const googleDns = new dns.promises.Resolver({ timeout: 3000, tries: 1 });
+googleDns.setServers(['8.8.8.8', '8.8.4.4']);
+
+// OpenDNS: 查询 myip.opendns.com 的 A 记录，返回值就是公网 IP
+async function queryOpenDns() {
+  const result = await openDns.resolve4('myip.opendns.com');
+  const ip = result[0];
+  if (!ip || !/^[\d.]+$/.test(ip)) throw new Error('OpenDNS returned invalid IP');
+  return ip;
+}
+
+// Google DNS: 查询 o-o.myaddr.l.google.com 的 TXT 记录，内容是公网 IP
+async function queryGoogleDns() {
+  const result = await googleDns.resolveTxt('o-o.myaddr.l.google.com');
+  // result 格式: [['ip'], ...]
+  const ip = result[0]?.[0];
+  if (!ip || !/^[\d.]+$/.test(ip)) throw new Error('Google DNS returned invalid IP');
+  return ip;
+}
+
+// ========== HTTPS 兜底方式 ==========
+
+const HTTPS_APIS = [
+  { url: 'https://ifconfig.me/ip', parse: d => d.trim() },
+  { url: 'https://api.ipify.org?format=json', parse: d => JSON.parse(d).ip },
+  { url: 'https://icanhazip.com', parse: d => d.trim() },
+];
+
+function queryHttps(api) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(api.url, { timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        try {
+          const ip = api.parse(data);
+          if (ip && /^[\d.]+$/.test(ip)) resolve(ip);
+          else reject(new Error('invalid IP'));
+        } catch (e) { reject(e); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+  });
+}
+
+async function queryHttpsFallback() {
+  for (const api of HTTPS_APIS) {
+    try { return await queryHttps(api); }
+    catch (e) { /* 继续下一个 */ }
+  }
+  throw new Error('All HTTPS IP APIs failed');
+}
+
+// ========== 主逻辑：依次尝试 DNS → DNS → HTTPS ==========
+
+const STRATEGIES = [
+  { name: 'opendns', fn: queryOpenDns },
+  { name: 'google-dns', fn: queryGoogleDns },
+  { name: 'https-fallback', fn: queryHttpsFallback },
+];
+
+async function fetchPublicIp() {
+  const errors = [];
+  for (const s of STRATEGIES) {
+    try {
+      const ip = await s.fn();
+      return { ip, source: s.name };
+    } catch (e) {
+      errors.push(`${s.name}: ${e.message}`);
+    }
+  }
+  throw new Error(`All strategies failed: ${errors.join('; ')}`);
+}
+
+// ========== 缓存 ==========
+
+let cache = { ip: null, source: null, time: 0 };
+const CACHE_TTL = 60000; // 60 秒
+
+/**
+ * 获取公网 IP
+ * @param {Object} [options]
+ * @param {boolean} [options.force] - 强制刷新，跳过缓存
+ * @param {number} [options.cacheTtl] - 缓存时间（毫秒），默认 60000
+ * @param {boolean} [options.includeSource] - 返回值包含数据来源
+ * @returns {Promise<string|{ip:string,source:string}>} 公网 IP 地址
+ */
+async function getPublicIp(options = {}) {
+  const ttl = options.cacheTtl || CACHE_TTL;
+  const now = Date.now();
+
+  if (!options.force && cache.ip && (now - cache.time) < ttl) {
+    return options.includeSource ? { ip: cache.ip, source: cache.source } : cache.ip;
+  }
+
+  try {
+    const { ip, source } = await fetchPublicIp();
+    cache = { ip, source, time: now };
+    return options.includeSource ? { ip, source } : ip;
+  } catch (e) {
+    // 失败时返回旧缓存
+    if (cache.ip) {
+      return options.includeSource ? { ip: cache.ip, source: cache.source + ' (cached)' } : cache.ip;
+    }
+    throw e;
+  }
+}
+
+module.exports = { getPublicIp };

package/lib/services.js

@@ -0,0 +1,43 @@
+const { runPsJson } = require('./ps');
+
+/**
+ * 获取 Windows 服务列表
+ * @param {Object} options
+ * @param {boolean} options.runningOnly - 只返回运行中的服务，默认 false
+ */
+async function getServicesInfo(options = {}) {
+  const runningOnly = options.runningOnly || false;
+  const filter = runningOnly ? '-Filter "State=\'Running\'"' : '';
+
+  const cmd = `
+$services = Get-CimInstance Win32_Service ${filter} | Sort-Object Name
+$list = @()
+foreach ($s in $services) {
+  $list += [PSCustomObject]@{
+    name = $s.Name
+    displayName = $s.DisplayName
+    state = $s.State
+    status = $s.Status
+    startMode = $s.StartMode
+    startName = $s.StartName
+    pathName = $s.PathName
+    description = $s.Description
+    processId = $s.ProcessId
+    acceptStop = $s.AcceptStop
+    acceptPause = $s.AcceptPause
+    desktopInteract = $s.DesktopInteract
+    exitCode = $s.ExitCode
+    serviceType = $s.ServiceType
+  }
+}
+[PSCustomObject]@{
+  total = $list.Count
+  running = ($list | Where-Object { $_.state -eq 'Running' }).Count
+  stopped = ($list | Where-Object { $_.state -eq 'Stopped' }).Count
+  services = $list
+} | ConvertTo-Json -Depth 4 -Compress
+`;
+  return runPsJson(cmd, { timeout: 20000 });
+}
+
+module.exports = { getServicesInfo };

package/lib/sysinfo-daemon.js

@@ -0,0 +1,188 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const readline = require('readline');
+
+const SCRIPT = path.join(__dirname, '..', 'scripts', 'sysinfo-daemon.ps1');
+
+/**
+ * 统一硬件信息常驻进程
+ * 一个 PowerShell 进程服务所有模块，每次查询只走 stdin/stdout，延迟 ~50ms
+ * 支持高频调用，内存占用 ~50MB
+ */
+class SysInfoDaemon {
+  constructor(options = {}) {
+    this.options = options;
+    this.process = null;
+    this.ready = false;
+    this.readyPromise = null;
+    this.queue = [];
+    this.currentRequest = null;
+    this.closed = false;
+    this.restartCount = 0;
+    this.maxRestarts = options.maxRestarts || 3;
+    // 缓存 TTL（毫秒），默认 system 30s，network 60s
+    this.systemCacheTtl = options.systemCacheTtl || 30000;
+    this.networkCacheTtl = options.networkCacheTtl || 30000;
+  }
+
+  async start() {
+    if (this.process) {
+      if (this.ready) return;
+      return this.readyPromise;
+    }
+
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.process = spawn('powershell', [
+        '-NoProfile',
+        '-ExecutionPolicy', 'Bypass',
+        '-File', SCRIPT,
+        '-SystemCacheTtl', (this.systemCacheTtl / 1000).toString(),
+        '-NetworkCacheTtl', (this.networkCacheTtl / 1000).toString()
+      ], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+      const rl = readline.createInterface({ input: this.process.stdout, terminal: false });
+      let readyReceived = false;
+
+      rl.on('line', (line) => {
+        line = line.trim();
+        if (!line) return;
+        if (!readyReceived) {
+          if (line === 'READY') {
+            readyReceived = true;
+            this.ready = true;
+            resolve();
+          } else {
+            reject(new Error(`Daemon failed to start: ${line}`));
+            this._cleanup();
+          }
+          return;
+        }
+        this._handleResponse(line);
+      });
+
+      this.process.stderr.on('data', (data) => {
+        if (this.options.verbose) console.error('[sysinfo-daemon stderr]', data.toString().trim());
+      });
+
+      this.process.on('exit', (code) => {
+        this.ready = false;
+        this.process = null;
+        rl.close();
+        const err = new Error(`SysInfoDaemon exited with code ${code}`);
+        this._rejectAllPending(err);
+        if (!this.closed && this.restartCount < this.maxRestarts) {
+          this.restartCount++;
+          if (this.options.verbose) console.error(`[sysinfo-daemon] exited, restarting (${this.restartCount}/${this.maxRestarts})`);
+          this.start().catch(() => {});
+        }
+      });
+
+      this.process.on('error', (err) => {
+        if (!readyReceived) reject(err);
+        this._cleanup();
+      });
+    });
+
+    return this.readyPromise;
+  }
+
+  // 通用请求方法
+  async _request(command) {
+    if (this.closed) throw new Error('Daemon is closed');
+    if (!this.process || !this.ready) await this.start();
+    return new Promise((resolve, reject) => {
+      this.queue.push({ command, resolve, reject });
+      this._processQueue();
+    });
+  }
+
+  // 各模块查询方法
+  async getSystem() { return this._request('system'); }
+  async getMemory() { return this._request('memory'); }
+  async getDisk() { return this._request('disk'); }
+  async getNetwork(options = {}) {
+    const includeWifi = options.includeWifi || false;
+    return this._request(`network:${includeWifi}`);
+  }
+  async getBattery() { return this._request('battery'); }
+  async getGpu() { return this._request('gpu'); }
+  async getUsb() { return this._request('usb'); }
+
+  async getProcesses(options = {}) {
+    const top = options.top || 0;
+    const sortBy = options.sortBy || 'memory';
+    const includeCmdLine = options.includeCommandLine || false;
+    return this._request(`processes:${top}:${sortBy}:${includeCmdLine}`);
+  }
+
+  async getServices(options = {}) {
+    const runningOnly = options.runningOnly || false;
+    return this._request(`services:${runningOnly}`);
+  }
+
+  async getAll(options = {}) {
+    const includeProcesses = options.includeProcesses || false;
+    const includeServices = options.includeServices || false;
+    return this._request(`all:${includeProcesses}:${includeServices}`);
+  }
+
+  async close() {
+    this.closed = true;
+    if (this.process) {
+      try { this.process.stdin.write('exit\n'); } catch (e) {}
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => { if (this.process) this.process.kill(); resolve(); }, 2000);
+        this.process.on('exit', () => { clearTimeout(timer); resolve(); });
+      });
+    }
+    this._cleanup();
+  }
+
+  _processQueue() {
+    if (this.currentRequest || this.queue.length === 0) return;
+    if (!this.process || !this.ready) return;
+    this.currentRequest = this.queue.shift();
+    try {
+      this.process.stdin.write(this.currentRequest.command + '\n');
+    } catch (e) {
+      this.currentRequest.reject(e);
+      this.currentRequest = null;
+      this._processQueue();
+    }
+  }
+
+  _handleResponse(line) {
+    if (!this.currentRequest) return;
+    try {
+      const data = JSON.parse(line);
+      if (data.error) {
+        this.currentRequest.reject(new Error(data.error));
+      } else {
+        this.currentRequest.resolve(data);
+      }
+    } catch (e) {
+      this.currentRequest.reject(new Error(`Failed to parse daemon response: ${e.message}`));
+    }
+    this.currentRequest = null;
+    this._processQueue();
+  }
+
+  _rejectAllPending(err) {
+    if (this.currentRequest) { this.currentRequest.reject(err); this.currentRequest = null; }
+    while (this.queue.length > 0) { this.queue.shift().reject(err); }
+  }
+
+  _cleanup() {
+    this.ready = false;
+    this.process = null;
+    this.currentRequest = null;
+  }
+}
+
+async function createSysInfoDaemon(options = {}) {
+  const daemon = new SysInfoDaemon(options);
+  await daemon.start();
+  return daemon;
+}
+
+module.exports = { SysInfoDaemon, createSysInfoDaemon };