@profullstack/hqtui-demo 0.1.0

package/src/system/index.ts

@@ -0,0 +1,56 @@
+import type { Collector, SystemSample } from "./types.ts";
+import { createSystemSimulation, type SimulationOptions } from "../simulation.ts";
+
+export type { Collector, SystemSample };
+
+/** Wraps the deterministic simulation in the Collector interface. */
+class SimulationCollector implements Collector {
+  source = "simulated";
+  unavailable: string[] = [];
+  private simulation;
+
+  constructor(options: SimulationOptions) {
+    this.simulation = createSystemSimulation(options);
+  }
+
+  async refresh(dt: number): Promise<void> {
+    this.simulation.update(dt);
+  }
+
+  current(): SystemSample {
+    return this.simulation.current();
+  }
+}
+
+export interface SourceOptions extends SimulationOptions {
+  /** Read the real machine. Falls back to the simulation if unsupported. */
+  real?: boolean;
+}
+
+/**
+ * Real metrics on Linux, macOS and Windows; a deterministic simulation
+ * everywhere else (and whenever `real` is off).
+ */
+export async function createCollector(options: SourceOptions = {}): Promise<Collector> {
+  if (!options.real) return new SimulationCollector(options);
+
+  try {
+    if (process.platform === "linux") {
+      const { LinuxCollector } = await import("./linux.ts");
+      return new LinuxCollector();
+    }
+    if (process.platform === "darwin") {
+      const { DarwinCollector } = await import("./darwin.ts");
+      return new DarwinCollector();
+    }
+    if (process.platform === "win32") {
+      const { WindowsCollector } = await import("./win32.ts");
+      return new WindowsCollector();
+    }
+  } catch {
+    // Fall through to the simulation rather than failing to start.
+  }
+  const fallback = new SimulationCollector(options);
+  fallback.source = `simulated (${process.platform} not supported)`;
+  return fallback;
+}

package/src/system/linux.ts

@@ -0,0 +1,258 @@
+import { readFile, readdir } from "node:fs/promises";
+import os from "node:os";
+import type { Collector, SystemSample } from "./types.ts";
+import { baseSample, loadAverage, primaryInterface, push, ratePerSecond, sh } from "./common.ts";
+
+async function read(path: string): Promise<string> {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+interface CpuTimes {
+  idle: number;
+  total: number;
+}
+
+function parseCpuTimes(text: string): CpuTimes[] {
+  const out: CpuTimes[] = [];
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("cpu")) continue;
+    const parts = line.trim().split(/\s+/);
+    const values = parts.slice(1).map(Number);
+    if (values.length < 4) continue;
+    const idle = values[3] + (values[4] ?? 0);
+    const total = values.reduce((a, b) => a + b, 0);
+    out.push({ idle, total });
+  }
+  return out;
+}
+
+function parseMeminfo(text: string): Record<string, number> {
+  const out: Record<string, number> = {};
+  for (const line of text.split("\n")) {
+    const match = /^(\w+):\s+(\d+)/.exec(line);
+    if (match) out[match[1]] = Number(match[2]) * 1024;
+  }
+  return out;
+}
+
+/** Reads everything from /proc and /sys — no external commands, no privileges. */
+export class LinuxCollector implements Collector {
+  source = "linux /proc";
+  unavailable: string[] = [];
+  private sample = baseSample();
+  private prevCpu: CpuTimes[] = [];
+  private prevDisk = new Map<string, [number, number]>();
+  private prevNet: [number, number] | null = null;
+  private sectorSize = 512;
+  private mounts: { device: string; mount: string }[] = [];
+
+  async refresh(dt: number): Promise<void> {
+    const s = this.sample;
+    const [stat, meminfo, uptime, diskstats, netdev] = await Promise.all([
+      read("/proc/stat"),
+      read("/proc/meminfo"),
+      read("/proc/uptime"),
+      read("/proc/diskstats"),
+      read("/proc/net/dev"),
+    ]);
+
+    // CPU — deltas against the previous reading.
+    const times = parseCpuTimes(stat);
+    if (this.prevCpu.length === times.length && times.length > 0) {
+      const usage = times.map((now, i) => {
+        const prev = this.prevCpu[i];
+        const totalDelta = now.total - prev.total;
+        const idleDelta = now.idle - prev.idle;
+        if (totalDelta <= 0) return 0;
+        return Math.max(0, Math.min(1, 1 - idleDelta / totalDelta));
+      });
+      s.cpu.total = usage[0];
+      s.cpu.cores = usage.slice(1);
+      if (s.cpu.cores.length === 0) s.cpu.cores = [s.cpu.total];
+    }
+    this.prevCpu = times;
+    push(s.cpu.history, s.cpu.total * 100);
+    s.cpu.load = loadAverage();
+    const cpus = os.cpus();
+    s.cpu.model = cpus[0]?.model?.trim() ?? s.cpu.model;
+    s.cpu.frequencyGhz = (cpus.reduce((a, c) => a + c.speed, 0) / Math.max(1, cpus.length)) / 1000;
+
+    // Context switches and process/thread counts.
+    const ctxt = /^ctxt (\d+)/m.exec(stat);
+    if (ctxt) s.system.contextSwitches = Number(ctxt[1]);
+    const procs = /^procs_running (\d+)/m.exec(stat);
+    if (procs) s.system.threadCount = Number(procs[1]);
+
+    // Memory.
+    const mem = parseMeminfo(meminfo);
+    if (mem.MemTotal) {
+      s.memory.total = mem.MemTotal;
+      s.memory.free = mem.MemFree ?? 0;
+      s.memory.available = mem.MemAvailable ?? mem.MemFree ?? 0;
+      s.memory.cached = mem.Cached ?? 0;
+      s.memory.buffers = mem.Buffers ?? 0;
+      s.memory.used = mem.MemTotal - s.memory.available;
+      s.memory.swapTotal = mem.SwapTotal ?? 0;
+      s.memory.swapUsed = (mem.SwapTotal ?? 0) - (mem.SwapFree ?? 0);
+    }
+    push(s.memory.history, (s.memory.used / Math.max(1, s.memory.total)) * 100);
+
+    if (uptime) s.system.uptime = Number(uptime.split(" ")[0]);
+
+    // Disks: throughput from /proc/diskstats, capacity from `df`.
+    if (this.mounts.length === 0) await this.loadMounts();
+    const stats = new Map<string, [number, number]>();
+    for (const line of diskstats.split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 14) continue;
+      const name = parts[2];
+      if (/^(loop|ram|dm-|sr)/.test(name)) continue;
+      stats.set(name, [Number(parts[5]) * this.sectorSize, Number(parts[9]) * this.sectorSize]);
+    }
+
+    if (s.disks.length === 0) {
+      for (const mount of this.mounts.slice(0, 4)) {
+        s.disks.push({
+          device: mount.device,
+          mount: mount.mount,
+          type: "disk",
+          total: 0, used: 0,
+          readRate: 0, writeRate: 0, readHistory: [], writeHistory: [],
+          iops: [0, 0], temperature: 0,
+        });
+      }
+    }
+    for (const disk of s.disks) {
+      const base = disk.device.replace(/p?\d+$/, "");
+      const now = stats.get(disk.device) ?? stats.get(base);
+      if (now) {
+        const prev = this.prevDisk.get(disk.device);
+        if (prev) {
+          disk.readRate = ratePerSecond(now[0], prev[0], dt);
+          disk.writeRate = ratePerSecond(now[1], prev[1], dt);
+        }
+        this.prevDisk.set(disk.device, now);
+      }
+      push(disk.readHistory, disk.readRate);
+      push(disk.writeHistory, disk.writeRate);
+      disk.iops = [Math.round(disk.readRate / 4096), Math.round(disk.writeRate / 4096)];
+    }
+    await this.updateCapacity();
+
+    // Network.
+    const iface = primaryInterface();
+    s.network.interface = iface.name;
+    s.network.ip = iface.ip;
+    s.network.mac = iface.mac;
+    for (const line of netdev.split("\n")) {
+      const match = /^\s*([\w.-]+):\s*(\d+)(?:\s+\d+){7}\s+(\d+)/.exec(line);
+      if (!match || match[1] !== iface.name) continue;
+      const now: [number, number] = [Number(match[2]), Number(match[3])];
+      if (this.prevNet) {
+        s.network.downRate = ratePerSecond(now[0], this.prevNet[0], dt);
+        s.network.upRate = ratePerSecond(now[1], this.prevNet[1], dt);
+      }
+      s.network.downTotal = now[0];
+      s.network.upTotal = now[1];
+      this.prevNet = now;
+    }
+    push(s.network.downHistory, s.network.downRate);
+    push(s.network.upHistory, s.network.upRate);
+    s.network.downPeak = Math.max(s.network.downPeak, s.network.downRate);
+    s.network.upPeak = Math.max(s.network.upPeak, s.network.upRate);
+    const speed = await read(`/sys/class/net/${iface.name}/speed`);
+    s.network.speed = speed.trim() && Number(speed) > 0 ? `${Number(speed) / 1000} Gb/s` : "-";
+
+    await Promise.all([this.updateProcesses(), this.updateTemperatures()]);
+  }
+
+  private async loadMounts(): Promise<void> {
+    const text = await read("/proc/mounts");
+    const seen = new Set<string>();
+    for (const line of text.split("\n")) {
+      const [device, mount, type] = line.split(" ");
+      if (!device?.startsWith("/dev/")) continue;
+      if (!["ext4", "xfs", "btrfs", "zfs", "f2fs", "ext3", "vfat", "apfs", "overlay"].includes(type)) continue;
+      const name = device.replace("/dev/", "");
+      if (seen.has(name)) continue;
+      seen.add(name);
+      this.mounts.push({ device: name, mount });
+    }
+    if (this.mounts.length === 0) this.mounts.push({ device: "root", mount: "/" });
+  }
+
+  private async updateCapacity(): Promise<void> {
+    const text = await sh("df", ["-kP", ...this.sample.disks.map((d) => d.mount)]);
+    const lines = text.trim().split("\n").slice(1);
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 6) continue;
+      const mount = parts[parts.length - 1];
+      const disk = this.sample.disks.find((d) => d.mount === mount);
+      if (!disk) continue;
+      disk.total = Number(parts[1]) * 1024;
+      disk.used = Number(parts[2]) * 1024;
+    }
+  }
+
+  private async updateProcesses(): Promise<void> {
+    const text = await sh("ps", ["-eo", "pid,comm,pcpu,pmem,rss,nlwp,user,state,args", "--sort=-pcpu"]);
+    if (!text) {
+      if (!this.unavailable.includes("processes")) this.unavailable.push("processes");
+      return;
+    }
+    const lines = text.trim().split("\n").slice(1, 60);
+    this.sample.processes = lines.map((line) => {
+      const parts = line.trim().split(/\s+/);
+      return {
+        pid: Number(parts[0]),
+        name: parts[1] ?? "-",
+        cpu: Number(parts[2]) || 0,
+        mem: Number(parts[3]) || 0,
+        rss: (Number(parts[4]) || 0) * 1024,
+        threads: Number(parts[5]) || 1,
+        user: parts[6] ?? "-",
+        state: parts[7] ?? "-",
+        command: parts.slice(8).join(" "),
+      };
+    });
+    this.sample.system.processCount = this.sample.processes.length;
+  }
+
+  private async updateTemperatures(): Promise<void> {
+    const out: { label: string; value: number; max: number }[] = [];
+    try {
+      const zones = await readdir("/sys/class/hwmon");
+      for (const zone of zones) {
+        const base = `/sys/class/hwmon/${zone}`;
+        const chip = (await read(`${base}/name`)).trim();
+        const entries = await readdir(base).catch(() => [] as string[]);
+        for (const entry of entries) {
+          if (!/^temp\d+_input$/.test(entry)) continue;
+          const raw = await read(`${base}/${entry}`);
+          const value = Number(raw) / 1000;
+          if (!Number.isFinite(value) || value <= 0 || value > 150) continue;
+          const label = (await read(`${base}/${entry.replace("_input", "_label")}`)).trim();
+          out.push({ label: label || `${chip} ${entry.replace("_input", "")}`, value, max: 100 });
+          if (out.length >= 10) break;
+        }
+        if (out.length >= 10) break;
+      }
+    } catch {
+      // hwmon is optional; containers and VMs frequently have none.
+    }
+    if (out.length === 0 && !this.unavailable.includes("temperatures")) {
+      this.unavailable.push("temperatures");
+    }
+    this.sample.temperatures = out;
+    this.sample.sensors = out.slice(0, 6).map((t) => ({ label: t.label, value: `${t.value.toFixed(1)} °C` }));
+  }
+
+  current(): SystemSample {
+    return this.sample;
+  }
+}

package/src/system/types.ts

@@ -0,0 +1,12 @@
+import type { SystemSample } from "../simulation.ts";
+
+export type { SystemSample };
+
+export interface Collector {
+  /** Human label shown in the UI: "linux /proc", "simulated", … */
+  source: string;
+  /** Metrics this platform could not provide. Shown in the help screen. */
+  unavailable: string[];
+  refresh(dt: number): Promise<void>;
+  current(): SystemSample;
+}

package/src/system/win32.ts

@@ -0,0 +1,132 @@
+import os from "node:os";
+import type { Collector, SystemSample } from "./types.ts";
+import { baseSample, loadAverage, primaryInterface, push, ratePerSecond, sh } from "./common.ts";
+
+/** One PowerShell round-trip per refresh; CIM covers CPU, memory, disk and net. */
+async function powershell(script: string): Promise<unknown> {
+  const out = await sh("powershell.exe", [
+    "-NoProfile", "-NonInteractive", "-Command",
+    `${script} | ConvertTo-Json -Compress -Depth 4`,
+  ], 8000);
+  if (!out.trim()) return null;
+  try {
+    return JSON.parse(out);
+  } catch {
+    return null;
+  }
+}
+
+function asArray<T>(value: unknown): T[] {
+  if (Array.isArray(value)) return value as T[];
+  if (value === null || value === undefined) return [];
+  return [value as T];
+}
+
+export class WindowsCollector implements Collector {
+  source = "Windows CIM";
+  unavailable = ["per-core detail", "temperatures"];
+  private sample = baseSample();
+  private prevNet: [number, number] | null = null;
+
+  async refresh(dt: number): Promise<void> {
+    const s = this.sample;
+
+    const cpu = await powershell(
+      "Get-CimInstance Win32_PerfFormattedData_PerfOS_Processor | Select-Object Name,PercentProcessorTime",
+    );
+    const entries = asArray<{ Name: string; PercentProcessorTime: number }>(cpu);
+    const cores = entries.filter((e) => e.Name !== "_Total");
+    const total = entries.find((e) => e.Name === "_Total");
+    if (total) s.cpu.total = Math.max(0, Math.min(1, Number(total.PercentProcessorTime) / 100));
+    if (cores.length > 0) {
+      s.cpu.cores = cores.map((c) => Math.max(0, Math.min(1, Number(c.PercentProcessorTime) / 100)));
+    }
+    push(s.cpu.history, s.cpu.total * 100);
+    s.cpu.load = loadAverage();
+
+    const mem = await powershell(
+      "Get-CimInstance Win32_OperatingSystem | Select-Object TotalVisibleMemorySize,FreePhysicalMemory,TotalVirtualMemorySize,FreeVirtualMemory,Caption,Version,NumberOfProcesses",
+    ) as Record<string, number | string> | null;
+    if (mem) {
+      const totalBytes = Number(mem.TotalVisibleMemorySize) * 1024;
+      const freeBytes = Number(mem.FreePhysicalMemory) * 1024;
+      s.memory.total = totalBytes;
+      s.memory.free = freeBytes;
+      s.memory.available = freeBytes;
+      s.memory.used = totalBytes - freeBytes;
+      s.memory.swapTotal = Number(mem.TotalVirtualMemorySize) * 1024;
+      s.memory.swapUsed = s.memory.swapTotal - Number(mem.FreeVirtualMemory) * 1024;
+      s.system.os = `${mem.Caption ?? "Windows"}`.trim();
+      s.system.processCount = Number(mem.NumberOfProcesses) || 0;
+    }
+    push(s.memory.history, (s.memory.used / Math.max(1, s.memory.total)) * 100);
+    s.system.uptime = os.uptime();
+
+    const disks = await powershell(
+      "Get-CimInstance Win32_LogicalDisk -Filter \"DriveType=3\" | Select-Object DeviceID,Size,FreeSpace",
+    );
+    const diskRows = asArray<{ DeviceID: string; Size: number; FreeSpace: number }>(disks);
+    if (s.disks.length === 0) {
+      for (const row of diskRows.slice(0, 4)) {
+        s.disks.push({
+          device: row.DeviceID, mount: row.DeviceID, type: "disk",
+          total: 0, used: 0, readRate: 0, writeRate: 0,
+          readHistory: [], writeHistory: [], iops: [0, 0], temperature: 0,
+        });
+      }
+    }
+    for (const disk of s.disks) {
+      const row = diskRows.find((r) => r.DeviceID === disk.device);
+      if (!row) continue;
+      disk.total = Number(row.Size) || 0;
+      disk.used = disk.total - (Number(row.FreeSpace) || 0);
+      push(disk.readHistory, disk.readRate);
+      push(disk.writeHistory, disk.writeRate);
+    }
+
+    const iface = primaryInterface();
+    s.network.interface = iface.name;
+    s.network.ip = iface.ip;
+    s.network.mac = iface.mac;
+    const net = await powershell(
+      "Get-CimInstance Win32_PerfRawData_Tcpip_NetworkInterface | Select-Object BytesReceivedPersec,BytesSentPersec",
+    );
+    const netRows = asArray<{ BytesReceivedPersec: number; BytesSentPersec: number }>(net);
+    if (netRows.length > 0) {
+      const received = netRows.reduce((a, r) => a + Number(r.BytesReceivedPersec || 0), 0);
+      const sent = netRows.reduce((a, r) => a + Number(r.BytesSentPersec || 0), 0);
+      if (this.prevNet) {
+        s.network.downRate = ratePerSecond(received, this.prevNet[0], dt);
+        s.network.upRate = ratePerSecond(sent, this.prevNet[1], dt);
+      }
+      s.network.downTotal = received;
+      s.network.upTotal = sent;
+      this.prevNet = [received, sent];
+    }
+    push(s.network.downHistory, s.network.downRate);
+    push(s.network.upHistory, s.network.upRate);
+    s.network.downPeak = Math.max(s.network.downPeak, s.network.downRate);
+    s.network.upPeak = Math.max(s.network.upPeak, s.network.upRate);
+
+    const processes = await powershell(
+      "Get-Process | Sort-Object CPU -Descending | Select-Object -First 40 Id,ProcessName,CPU,WorkingSet,Threads",
+    );
+    const rows = asArray<{ Id: number; ProcessName: string; CPU: number; WorkingSet: number; Threads: unknown }>(processes);
+    const totalMemory = Math.max(1, s.memory.total);
+    s.processes = rows.map((row) => ({
+      pid: Number(row.Id),
+      name: String(row.ProcessName),
+      cpu: Number(row.CPU) || 0,
+      mem: ((Number(row.WorkingSet) || 0) / totalMemory) * 100,
+      rss: Number(row.WorkingSet) || 0,
+      threads: Array.isArray(row.Threads) ? row.Threads.length : 1,
+      user: "-",
+      state: "R",
+      command: String(row.ProcessName),
+    }));
+  }
+
+  current(): SystemSample {
+    return this.sample;
+  }
+}