about-system 0.10.15 → 0.10.17

package/src/info/hardware-bench.test.ts

@@ -0,0 +1,220 @@
+/**
+ * @fileoverview The four Geekbench lookups share a table format
+ * (`[name, score, rank][]`) and a fuzzy matcher, so they're driven here with a
+ * small fixture rather than the multi-megabyte real tables.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../utils/platform", () => ({ IS_LINUX: true, IS_MAC: false, IS_WINDOWS: false }));
+
+const execCommand = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists: vi.fn() }));
+
+const files = vi.hoisted(() => ({
+  existing: new Set<string>(),
+  data: {} as Record<string, string>,
+}));
+const fsMock = vi.hoisted(() => ({
+  existsSync: vi.fn((p: string) => files.existing.has(p)),
+  readFileSync: vi.fn((p: string) => {
+    if (!(p in files.data)) throw new Error("ENOENT");
+    return files.data[p];
+  }),
+  writeFileSync: vi.fn(),
+}));
+vi.mock("fs", () => ({ ...fsMock, default: fsMock }));
+
+vi.mock("os", () => {
+  const api = { tmpdir: () => "/tmp", cpus: () => [], platform: () => "linux" };
+  return { ...api, default: api };
+});
+
+const h = await import("./hardware");
+import type { InfoContext } from "../types/internal-types";
+
+const CPU_TABLE = {
+  scores: [
+    ["AMD Ryzen 9 7950X", 3000, 1],
+    ["Intel Core i9-13900K", 2900, 2],
+    ["Apple M2 Pro", 2700, 3],
+    ["Qualcomm Snapdragon X Elite", 2500, 4],
+    ["AMD EPYC 7763", 2400, 5],
+    ["Mystery Chip 9000", 1000, 6],
+  ],
+};
+const GPU_TABLE = {
+  scores: [
+    ["NVIDIA GeForce RTX 4090", 300000, 1],
+    ["AMD Radeon RX 7900 XTX", 200000, 2],
+    ["Intel Arc A770", 100000, 3],
+    ["Obscure Accelerator", 50000, 4],
+  ],
+};
+
+const ctx = (cache: InfoContext["cache"] = {}): InfoContext => ({ cache });
+
+/** Make `cpu()`/`gpu()` resolve to a name via the (mocked) shell tools. */
+const resolveCpu = (name: string) =>
+  execCommand.mockImplementation((c: string) => (c === "lscpu" ? `Model name: ${name}` : ""));
+const resolveGpu = (name: string) =>
+  execCommand.mockImplementation((c: string) =>
+    c === "lspci" ? `01:00.0 VGA compatible controller: NVIDIA [${name}]` : "",
+  );
+
+beforeEach(() => {
+  files.existing = new Set(["cpu-geekbench.json", "gpu-geekbench.json"]);
+  files.data = {
+    "cpu-geekbench.json": JSON.stringify(CPU_TABLE),
+    "gpu-geekbench.json": JSON.stringify(GPU_TABLE),
+  };
+  execCommand.mockReset().mockReturnValue("");
+});
+
+describe("bench (CPU)", () => {
+  it("formats score, rank and percentile for the fuzzy-matched CPU", () => {
+    resolveCpu("AMD Ryzen 9 7950X");
+    expect(h.bench(ctx())).toBe("3k #1 Top 1%");
+  });
+
+  it("is empty with no CPU name or no fuzzy match", () => {
+    expect(h.bench(ctx())).toBe("");
+    resolveCpu("zzzzzzzzzzzz qqqqqqqq");
+    expect(h.bench(ctx())).toBe("");
+  });
+
+  it("is empty when the benchmark file is unreadable or malformed", () => {
+    resolveCpu("AMD Ryzen 9 7950X");
+    files.data["cpu-geekbench.json"] = "{not json";
+    expect(h.bench(ctx())).toBe("");
+  });
+
+  it("finds the table under src/bench or ./bench when not in the cwd", () => {
+    resolveCpu("AMD Ryzen 9 7950X");
+    files.existing = new Set(["src/bench/cpu-geekbench.json"]);
+    files.data = { "src/bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
+    expect(h.bench(ctx())).toBe("3k #1 Top 1%");
+
+    files.existing = new Set(["./bench/cpu-geekbench.json"]);
+    files.data = { "./bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
+    expect(h.bench(ctx())).toBe("3k #1 Top 1%");
+  });
+
+  it("falls back to the module-relative path when no known location exists", () => {
+    resolveCpu("AMD Ryzen 9 7950X");
+    files.existing = new Set();
+    files.data = {};
+    // Nothing readable anywhere → swallowed, cached as empty.
+    expect(h.bench(ctx())).toBe("");
+  });
+
+  it("serves from the cache", () => {
+    const c = ctx({ bench: { value: "cached", timestamp: Date.now() } });
+    expect(h.bench(c)).toBe("cached");
+  });
+});
+
+describe("cpu_bench_info", () => {
+  it.each([
+    ["AMD Ryzen 9 7950X", "Geekbench 6: 3k (Rank #1, Top 1%) - AMD"],
+    ["Intel Core i9-13900K", "Geekbench 6: 3k (Rank #2, Top 17%) - Intel"],
+    ["Apple M2 Pro", "Geekbench 6: 3k (Rank #3, Top 34%) - ARM"],
+    ["Qualcomm Snapdragon X Elite", "Geekbench 6: 3k (Rank #4, Top 50%) - ARM"],
+    ["AMD EPYC 7763", "Geekbench 6: 2k (Rank #5, Top 67%) - AMD"],
+    ["Mystery Chip 9000", "Geekbench 6: 1k (Rank #6, Top 84%) - Unknown"],
+  ])("labels %s with its architecture", (name, expected) => {
+    resolveCpu(name);
+    expect(h.cpu_bench_info(ctx())).toBe(expected);
+  });
+
+  it("is empty with no CPU, no match, or a bad table; and serves cache", () => {
+    expect(h.cpu_bench_info(ctx())).toBe("");
+    resolveCpu("zzzzzzzzzzzz qqqqqqqq");
+    expect(h.cpu_bench_info(ctx())).toBe("");
+    resolveCpu("AMD Ryzen 9 7950X");
+    files.data["cpu-geekbench.json"] = "oops";
+    expect(h.cpu_bench_info(ctx())).toBe("");
+    expect(
+      h.cpu_bench_info(ctx({ cpu_bench_info: { value: "cached", timestamp: Date.now() } })),
+    ).toBe("cached");
+  });
+
+  it("locates the table at the alternate paths", () => {
+    resolveCpu("AMD Ryzen 9 7950X");
+    files.existing = new Set(["src/bench/cpu-geekbench.json"]);
+    files.data = { "src/bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
+    expect(h.cpu_bench_info(ctx())).toContain("AMD");
+    files.existing = new Set(["./bench/cpu-geekbench.json"]);
+    files.data = { "./bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
+    expect(h.cpu_bench_info(ctx())).toContain("AMD");
+    files.existing = new Set();
+    files.data = {};
+    expect(h.cpu_bench_info(ctx())).toBe("");
+  });
+});
+
+describe("gpu_bench", () => {
+  it("formats the fuzzy-matched GPU", () => {
+    resolveGpu("GeForce RTX 4090");
+    expect(h.gpu_bench(ctx())).toBe("300k #1 Top 1%");
+  });
+
+  it("is empty with no GPU, no match, or a bad table; serves cache", () => {
+    expect(h.gpu_bench(ctx())).toBe("");
+    resolveGpu("zzzzzzzzzzzz qqqqqqqq");
+    expect(h.gpu_bench(ctx())).toBe("");
+    resolveGpu("GeForce RTX 4090");
+    files.data["gpu-geekbench.json"] = "oops";
+    expect(h.gpu_bench(ctx())).toBe("");
+    expect(h.gpu_bench(ctx({ gpu_bench: { value: "c", timestamp: Date.now() } }))).toBe("c");
+  });
+
+  it("locates the table at the alternate paths", () => {
+    resolveGpu("GeForce RTX 4090");
+    files.existing = new Set(["src/bench/gpu-geekbench.json"]);
+    files.data = { "src/bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
+    expect(h.gpu_bench(ctx())).toBe("300k #1 Top 1%");
+    files.existing = new Set(["./bench/gpu-geekbench.json"]);
+    files.data = { "./bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
+    expect(h.gpu_bench(ctx())).toBe("300k #1 Top 1%");
+    files.existing = new Set();
+    files.data = {};
+    expect(h.gpu_bench(ctx())).toBe("");
+  });
+});
+
+describe("gpu_bench_info", () => {
+  it.each([
+    ["GeForce RTX 4090", "Geekbench 6: 300k (Rank #1, Top 1%) - NVIDIA"],
+    ["Radeon RX 7900 XTX", "Geekbench 6: 200k (Rank #2, Top 25%) - AMD"],
+    ["Intel Arc A770", "Geekbench 6: 100k (Rank #3, Top 50%) - Intel"],
+    ["Obscure Accelerator", "Geekbench 6: 50k (Rank #4, Top 75%) - Unknown"],
+  ])("labels %s with its vendor", (name, expected) => {
+    resolveGpu(name);
+    expect(h.gpu_bench_info(ctx())).toBe(expected);
+  });
+
+  it("is empty with no GPU, no match, or a bad table; serves cache", () => {
+    expect(h.gpu_bench_info(ctx())).toBe("");
+    resolveGpu("zzzzzzzzzzzz qqqqqqqq");
+    expect(h.gpu_bench_info(ctx())).toBe("");
+    resolveGpu("GeForce RTX 4090");
+    files.data["gpu-geekbench.json"] = "oops";
+    expect(h.gpu_bench_info(ctx())).toBe("");
+    expect(
+      h.gpu_bench_info(ctx({ gpu_bench_info: { value: "c", timestamp: Date.now() } })),
+    ).toBe("c");
+  });
+
+  it("locates the table at the alternate paths", () => {
+    resolveGpu("GeForce RTX 4090");
+    files.existing = new Set(["src/bench/gpu-geekbench.json"]);
+    files.data = { "src/bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
+    expect(h.gpu_bench_info(ctx())).toContain("NVIDIA");
+    files.existing = new Set(["./bench/gpu-geekbench.json"]);
+    files.data = { "./bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
+    expect(h.gpu_bench_info(ctx())).toContain("NVIDIA");
+    files.existing = new Set();
+    files.data = {};
+    expect(h.gpu_bench_info(ctx())).toBe("");
+  });
+});

package/src/info/hardware-probes.test.ts

@@ -0,0 +1,208 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const flags = vi.hoisted(() => ({ linux: true, mac: false, windows: false }));
+vi.mock("../utils/platform", () => ({
+  get IS_LINUX() {
+    return flags.linux;
+  },
+  get IS_MAC() {
+    return flags.mac;
+  },
+  get IS_WINDOWS() {
+    return flags.windows;
+  },
+}));
+
+const execCommand = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists: vi.fn() }));
+
+const fsMock = vi.hoisted(() => ({
+  existsSync: vi.fn(() => false),
+  readFileSync: vi.fn(() => ""),
+  writeFileSync: vi.fn(),
+}));
+vi.mock("fs", () => ({ ...fsMock, default: fsMock }));
+
+const osMock = vi.hoisted(() => ({
+  cpus: vi.fn(() => [] as { model: string }[]),
+  tmpdir: vi.fn(() => "/tmp"),
+  platform: vi.fn(() => "linux"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const h = await import("./hardware");
+import type { InfoContext } from "../types/internal-types";
+
+const ctx = (): InfoContext => ({ cache: {} });
+const platform = (k: "linux" | "mac" | "windows" | "other") => {
+  flags.linux = k === "linux";
+  flags.mac = k === "mac";
+  flags.windows = k === "windows";
+};
+
+beforeEach(() => {
+  platform("linux");
+  execCommand.mockReset().mockReturnValue("");
+  fsMock.readFileSync.mockReset().mockReturnValue("");
+  osMock.cpus.mockReset().mockReturnValue([]);
+});
+
+afterEach(() => {
+  delete process.env.DISPLAY;
+});
+
+describe("cpu", () => {
+  it("reads the model from lscpu on Linux and trims `with ...` suffixes", () => {
+    execCommand.mockReturnValue("Architecture: x86_64\nModel name:  AMD Ryzen 7 5800X with Radeon\nFlags: a");
+    expect(h.cpu(ctx())).toBe("AMD Ryzen 7 5800X");
+  });
+
+  it("stops the lscpu model at a comma", () => {
+    execCommand.mockReturnValue("Model name: Intel(R) Core(TM) i7, 8 cores");
+    expect(h.cpu(ctx())).toBe("Intel(R) Core(TM) i7");
+  });
+
+  it("falls back to /proc/cpuinfo model name, then Hardware", () => {
+    fsMock.readFileSync.mockReturnValue("processor : 0\nmodel name : Fancy CPU\n");
+    expect(h.cpu(ctx())).toBe("Fancy CPU");
+    fsMock.readFileSync.mockReturnValue("Hardware : BCM2711\n");
+    expect(h.cpu(ctx())).toBe("BCM2711");
+  });
+
+  it("is empty when Linux offers no CPU name", () => {
+    fsMock.readFileSync.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(h.cpu(ctx())).toBe("");
+    fsMock.readFileSync.mockReturnValue("nothing useful");
+    expect(h.cpu(ctx())).toBe("");
+  });
+
+  it("uses wmic on Windows, then PowerShell", () => {
+    platform("windows");
+    execCommand.mockReturnValue("Name=Intel(R) Core(TM) i9-9900K CPU @ 3.60GHz\r\n");
+    expect(h.cpu(ctx())).toBe("Intel(R) Core(TM) i9-9900K CPU @ 3.60GHz");
+    execCommand.mockImplementation((c: string) => (c.startsWith("wmic") ? "" : "Ryzen 5 3600\r\n"));
+    expect(h.cpu(ctx())).toBe("Ryzen 5 3600");
+    execCommand.mockReturnValue("");
+    expect(h.cpu(ctx())).toBe("");
+  });
+
+  it("uses os.cpus elsewhere (macOS)", () => {
+    platform("mac");
+    osMock.cpus.mockReturnValue([{ model: "Apple M2\r\nPro " }]);
+    expect(h.cpu(ctx())).toBe("Apple M2 Pro");
+    osMock.cpus.mockReturnValue([]);
+    expect(h.cpu(ctx())).toBe("");
+  });
+
+  it("serves from the cache", () => {
+    const c = ctx();
+    execCommand.mockReturnValue("Model name: Cached CPU");
+    h.cpu(c);
+    execCommand.mockReturnValue("Model name: Other");
+    expect(h.cpu(c)).toBe("Cached CPU");
+  });
+});
+
+describe("gpu", () => {
+  it("lists display-class lspci devices using the bracketed marketing name", () => {
+    execCommand.mockReturnValue(
+      [
+        "00:02.0 VGA compatible controller: Intel Corporation UHD Graphics 630 [UHD Graphics 630]",
+        "01:00.0 VGA compatible controller: NVIDIA Corporation GA104 [GeForce RTX 3070] (rev a1)",
+        "01:00.1 Audio device: NVIDIA Corporation GA104 High Definition Audio",
+        "02:00.0 Ethernet controller: Realtek",
+        "03:00.0 3D controller: NVIDIA Corporation GA104 [GeForce RTX 3070]",
+      ].join("\n"),
+    );
+    expect(h.gpu(ctx())).toBe("UHD Graphics 630, GeForce RTX 3070");
+  });
+
+  it("strips the class prefix and revision when there are no brackets", () => {
+    execCommand.mockReturnValue("00:02.0 VGA compatible controller: Intel Corporation HD Graphics (rev 09)");
+    expect(h.gpu(ctx())).toBe("Intel Corporation HD Graphics");
+  });
+
+  it("is empty when no GPU is found, or lspci fails", () => {
+    execCommand.mockReturnValue("00:1f.0 ISA bridge: Intel");
+    expect(h.gpu(ctx())).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(h.gpu(ctx())).toBe("");
+  });
+
+  it("lists wmic adapters on Windows, ignoring Microsoft Basic", () => {
+    platform("windows");
+    execCommand.mockReturnValue("Name=NVIDIA GeForce RTX 4090\r\nName=Microsoft Basic Display Adapter\r\nName=Intel UHD\r\n");
+    expect(h.gpu(ctx())).toBe("NVIDIA GeForce RTX 4090, Intel UHD");
+  });
+
+  it("falls back to PowerShell on Windows", () => {
+    platform("windows");
+    execCommand.mockImplementation((c: string) =>
+      c.startsWith("wmic") ? "" : "AMD Radeon RX 7900\r\nMicrosoft Basic Render\r\n\r\n",
+    );
+    expect(h.gpu(ctx())).toBe("AMD Radeon RX 7900");
+    execCommand.mockReturnValue("");
+    expect(h.gpu(ctx())).toBe("");
+  });
+
+  it("lists chipset models on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue("Graphics:\n  Chipset Model: Apple M2 Pro\n  Chipset Model: AMD Radeon Pro");
+    expect(h.gpu(ctx())).toBe("Apple M2 Pro, AMD Radeon Pro");
+    execCommand.mockReturnValue("none");
+    expect(h.gpu(ctx())).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(h.gpu(ctx())).toBe("");
+  });
+
+  it("is empty on unknown platforms and serves from the cache", () => {
+    platform("other");
+    const c = ctx();
+    expect(h.gpu(c)).toBe("");
+    platform("linux");
+    execCommand.mockReturnValue("00:02.0 VGA compatible controller: Intel UHD Graphics [UHD]");
+    expect(h.gpu(c)).toBe("");
+  });
+});
+
+describe("screen_resolution", () => {
+  it("parses the xrandr geometry on Linux when DISPLAY is set", () => {
+    process.env.DISPLAY = ":0";
+    execCommand.mockReturnValue("Screen 0: minimum 8 x 8\nHDMI-1 connected primary 2560x1440+0+0");
+    expect(h.screen_resolution()).toBe("2560x1440");
+  });
+
+  it("is empty without DISPLAY, without a match, or when xrandr throws", () => {
+    expect(h.screen_resolution()).toBe("");
+    process.env.DISPLAY = ":0";
+    execCommand.mockReturnValue("nothing");
+    expect(h.screen_resolution()).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(h.screen_resolution()).toBe("");
+  });
+
+  it("parses the system_profiler resolution on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue("Resolution: 3024 x 1964 Retina");
+    expect(h.screen_resolution()).toBe("3024x1964");
+    execCommand.mockReturnValue("nope");
+    expect(h.screen_resolution()).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(h.screen_resolution()).toBe("");
+  });
+
+  it("is empty on other platforms", () => {
+    platform("windows");
+    expect(h.screen_resolution()).toBe("");
+  });
+});

package/src/info/hardware.ts

@@ -105,7 +105,7 @@ export function cpu(context: InfoContext): string {
     return "";
   }
 
-  cpuName = cpuName.trim().replace(/with .*/, "");
+  cpuName = cpuName.trim().replace(/with .*/, "").trim();
 
   setCachedValue(context.cache, "cpu", cpuName);
   return cpuName;