about-system 0.10.15 → 0.10.17

package/src/info/process.test.ts

@@ -0,0 +1,112 @@
+import { 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 osMock = vi.hoisted(() => ({
+  uptime: vi.fn(() => 0),
+  tmpdir: vi.fn(() => "/tmp"),
+  platform: vi.fn(() => "linux"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const p = await import("./process");
+import type { InfoContext } from "../types/internal-types";
+
+const ctx = (): InfoContext => ({ cache: {} });
+const platform = (v: "linux" | "mac" | "windows") => {
+  flags.linux = v === "linux";
+  flags.mac = v === "mac";
+  flags.windows = v === "windows";
+};
+
+beforeEach(() => {
+  platform("linux");
+  execCommand.mockReset().mockReturnValue("");
+});
+
+describe("top_process", () => {
+  it("reports the busiest process on Linux with a single percent sign", () => {
+    execCommand.mockReturnValue(" 12.5 /usr/bin/node\n  3.0 bash");
+    expect(p.top_process(ctx())).toBe("12% node");
+  });
+
+  it("is empty when ps output cannot be parsed on Linux", () => {
+    execCommand.mockReturnValue("");
+    expect(p.top_process(ctx())).toBe("");
+  });
+
+  it("parses `ps -r` output on macOS and rounds the CPU value", () => {
+    platform("mac");
+    execCommand.mockReturnValue("%CPU COMM\n 37.6 Google Chrome\n 2.0 Finder");
+    expect(p.top_process(ctx())).toBe("38% Google Chrome");
+  });
+
+  it("is empty on macOS when there is no data row or it is malformed", () => {
+    platform("mac");
+    execCommand.mockReturnValue("%CPU COMM");
+    expect(p.top_process(ctx())).toBe("");
+    execCommand.mockReturnValue("%CPU COMM\nabc");
+    expect(p.top_process(ctx())).toBe("");
+  });
+
+  it("is empty on Windows", () => {
+    platform("windows");
+    expect(p.top_process(ctx())).toBe("");
+  });
+
+  it("serves from the cache", () => {
+    const c = ctx();
+    execCommand.mockReturnValue("5.1 node");
+    expect(p.top_process(c)).toBe("5% node");
+    execCommand.mockReturnValue("99.9 other");
+    expect(p.top_process(c)).toBe("5% node");
+  });
+});
+
+describe("uptime", () => {
+  it.each([
+    [0, "0d 0h 0m"],
+    [59, "0d 0h 0m"],
+    [3_660, "0d 1h 1m"],
+    [90_061, "1d 1h 1m"],
+    [86_400 * 10 + 7_200 + 1_800, "10d 2h 30m"],
+  ])("formats %i seconds", (secs, expected) => {
+    osMock.uptime.mockReturnValue(secs);
+    expect(p.uptime()).toBe(expected);
+  });
+});
+
+describe("users_logged_in", () => {
+  it("counts non-blank `who` lines", () => {
+    execCommand.mockReturnValue("a tty1\n\nb pts/0\n");
+    expect(p.users_logged_in()).toBe("2 users");
+  });
+
+  it("is empty with nobody logged in or on Windows", () => {
+    execCommand.mockReturnValue("");
+    expect(p.users_logged_in()).toBe("");
+    platform("windows");
+    expect(p.users_logged_in()).toBe("");
+  });
+
+  it("is empty when the command throws", () => {
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(p.users_logged_in()).toBe("");
+  });
+});

package/src/info/process.ts

@@ -26,7 +26,7 @@ export function top_process(context: InfoContext): string {
       const lines = ps.split("\n");
       if (lines.length > 0) {
         const topProcess = lines[0].trim().replace(/\s+/, " ").split(" ");
-        const cpu = topProcess[0].replace(/\.\d+/, "%");
+        const cpu = topProcess[0].replace(/\.\d+/, "");
         const process = topProcess[1].split("/").pop();
         const result = `${cpu}% ${process}`;
         setCachedValue(context.cache, "top_process", result);

package/src/info/settings.test.ts

@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const fsMock = vi.hoisted(() => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+}));
+vi.mock("fs", () => ({ ...fsMock, default: fsMock }));
+
+const osMock = vi.hoisted(() => ({
+  homedir: vi.fn(() => "/home/ada"),
+  tmpdir: vi.fn(() => "/tmpdir"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const s = await import("./settings");
+
+beforeEach(() => {
+  for (const f of Object.values(fsMock)) f.mockReset();
+});
+
+describe("paths", () => {
+  it("places settings under ~/.config and the cache under the temp dir", () => {
+    expect(s.SETTINGS_FILE).toBe("/home/ada/.config/systeminfo-settings.json");
+    expect(s.CACHE_FILE).toBe("/tmpdir/systeminfo-cache.json");
+  });
+});
+
+describe("defaults", () => {
+  it("defines a color, emoji and label for every displayed item", () => {
+    const shown = s.DEFAULT_SETTINGS.display_order.flat();
+    for (const key of shown) {
+      if (key === "pacman" || key === "bench" || key === "gpu_bench") continue;
+      expect(s.DEFAULT_SETTINGS.labels).toHaveProperty(key);
+    }
+    for (const color of Object.values(s.DEFAULT_SETTINGS.colors)) {
+      if (color === "multicolor") continue;
+      expect(s.colors).toHaveProperty(color);
+      expect(s.backgrounds).toHaveProperty(color);
+    }
+  });
+
+  it("uses ANSI escapes for every palette entry", () => {
+    for (const v of [...Object.values(s.colors), ...Object.values(s.backgrounds)]) {
+      expect(v.startsWith("\x1b[")).toBe(true);
+    }
+  });
+
+  it("falls back to 100 columns when stdout has no width", () => {
+    expect(s.DEFAULT_SETTINGS.display.line_wrap_length).toBeGreaterThan(0);
+  });
+});
+
+describe("loadSettings", () => {
+  it("returns the defaults when no settings file exists", () => {
+    fsMock.existsSync.mockReturnValue(false);
+    expect(s.loadSettings()).toBe(s.DEFAULT_SETTINGS);
+  });
+
+  it("shallow-merges the user's file over the defaults", () => {
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.readFileSync.mockReturnValue(JSON.stringify({ labels: { user: "Me" } }));
+    const loaded = s.loadSettings();
+    expect(loaded.labels).toEqual({ user: "Me" });
+    expect(loaded.colors).toBe(s.DEFAULT_SETTINGS.colors);
+    expect(fsMock.readFileSync).toHaveBeenCalledWith(s.SETTINGS_FILE, "utf8");
+  });
+
+  it("falls back to the defaults on malformed JSON or a read error", () => {
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.readFileSync.mockReturnValue("{not json");
+    expect(s.loadSettings()).toBe(s.DEFAULT_SETTINGS);
+    fsMock.readFileSync.mockImplementation(() => {
+      throw new Error("EACCES");
+    });
+    expect(s.loadSettings()).toBe(s.DEFAULT_SETTINGS);
+  });
+});
+
+describe("saveSettings", () => {
+  it("creates the config dir when missing and writes pretty JSON", () => {
+    fsMock.existsSync.mockReturnValue(false);
+    expect(s.saveSettings(s.DEFAULT_SETTINGS)).toBe(true);
+    expect(fsMock.mkdirSync).toHaveBeenCalledWith("/home/ada/.config", { recursive: true });
+    const [file, body] = fsMock.writeFileSync.mock.calls[0];
+    expect(file).toBe(s.SETTINGS_FILE);
+    expect(JSON.parse(body)).toEqual(JSON.parse(JSON.stringify(s.DEFAULT_SETTINGS)));
+    expect(body).toContain('\n  "display_order"');
+  });
+
+  it("skips mkdir when the dir exists", () => {
+    fsMock.existsSync.mockReturnValue(true);
+    expect(s.saveSettings(s.DEFAULT_SETTINGS)).toBe(true);
+    expect(fsMock.mkdirSync).not.toHaveBeenCalled();
+  });
+
+  it("reports failure instead of throwing", () => {
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.writeFileSync.mockImplementation(() => {
+      throw new Error("EROFS");
+    });
+    expect(s.saveSettings(s.DEFAULT_SETTINGS)).toBe(false);
+  });
+});

package/src/info/software.test.ts

@@ -0,0 +1,157 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const flags = vi.hoisted(() => ({ windows: false }));
+vi.mock("../utils/platform", () => ({
+  get IS_WINDOWS() {
+    return flags.windows;
+  },
+  IS_LINUX: true,
+  IS_MAC: false,
+}));
+
+const execCommand = vi.hoisted(() => vi.fn());
+const commandExists = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists }));
+
+const osMock = vi.hoisted(() => ({
+  userInfo: vi.fn(() => ({ shell: "/bin/zsh" })),
+  tmpdir: vi.fn(() => "/tmp"),
+  platform: vi.fn(() => "linux"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+vi.mock("process", () => ({ default: { ppid: 4242 } }));
+
+const s = await import("./software");
+import type { InfoContext } from "../types/internal-types";
+
+const ctx = (): InfoContext => ({ cache: {} });
+
+beforeEach(() => {
+  flags.windows = false;
+  execCommand.mockReset().mockReturnValue("");
+  commandExists.mockReset().mockReturnValue(false);
+  osMock.userInfo.mockReset().mockReturnValue({ shell: "/bin/zsh" });
+});
+
+describe("shell", () => {
+  it("returns the login shell's basename", () => {
+    expect(s.shell(ctx())).toBe("zsh");
+  });
+
+  it("falls back to the parent process name when there is no login shell", () => {
+    osMock.userInfo.mockReturnValue({ shell: "" });
+    execCommand.mockReturnValue("/usr/bin/fish");
+    expect(s.shell(ctx())).toBe("fish");
+    expect(execCommand).toHaveBeenCalledWith("ps -p 4242 -o comm=");
+  });
+
+  it("falls back to ps when userInfo throws", () => {
+    osMock.userInfo.mockImplementation(() => {
+      throw new Error("x");
+    });
+    execCommand.mockReturnValue("bash");
+    expect(s.shell(ctx())).toBe("bash");
+  });
+
+  it("is empty when nothing identifies the shell", () => {
+    osMock.userInfo.mockReturnValue({ shell: "" });
+    execCommand.mockReturnValue("");
+    expect(s.shell(ctx())).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(s.shell(ctx())).toBe("");
+  });
+
+  it("is empty on Windows and serves from cache", () => {
+    flags.windows = true;
+    const c = ctx();
+    expect(s.shell(c)).toBe("");
+    flags.windows = false;
+    expect(s.shell(c)).toBe("");
+  });
+});
+
+describe("packages", () => {
+  it("lists the package managers/tools that exist", () => {
+    commandExists.mockImplementation((c: string) => ["apt", "npm", "bun"].includes(c));
+    const c = ctx();
+    expect(s.packages(c)).toBe("apt npm bun");
+    commandExists.mockReturnValue(false);
+    expect(s.packages(c)).toBe("apt npm bun");
+  });
+
+  it("is empty when nothing is installed", () => {
+    expect(s.packages(ctx())).toBe("");
+  });
+});
+
+describe("common_versions", () => {
+  const outputs: Record<string, string> = {
+    "node --version": "v22.1.0",
+    "git --version": "git version 2.44.0",
+    "docker --version": "Docker version 26.1.0, build abc",
+    "python3 --version": "Python 3.12.3",
+    "go version": "go version go1.22.0 linux/amd64",
+    "rustc --version": "rustc 1.77.0 (abc 2024-03-17)",
+  };
+
+  it("cleans each tool's version output", () => {
+    commandExists.mockReturnValue(true);
+    execCommand.mockImplementation((c: string) => outputs[c]);
+    expect(s.common_versions(ctx())).toBe(
+      "node:22.1.0 git:2.44.0 docker:26.1.0 python3:3.12.3 go:1.22.0 rustc:1.77.0",
+    );
+  });
+
+  it("skips missing tools, empty versions and failing commands", () => {
+    commandExists.mockImplementation((c: string) => ["node", "git", "go"].includes(c));
+    execCommand.mockImplementation((c: string) => {
+      if (c.startsWith("git")) return "";
+      if (c.startsWith("go")) throw new Error("x");
+      return outputs[c];
+    });
+    const c = ctx();
+    expect(s.common_versions(c)).toBe("node:22.1.0");
+    execCommand.mockReturnValue("v1");
+    expect(s.common_versions(c)).toBe("node:22.1.0");
+  });
+});
+
+describe("containers", () => {
+  it("is empty without docker", () => {
+    expect(s.containers(ctx())).toBe("");
+  });
+
+  it("is empty when no containers are running", () => {
+    commandExists.mockReturnValue(true);
+    execCommand.mockReturnValue("");
+    expect(s.containers(ctx())).toBe("");
+  });
+
+  it("lists names with their de-duplicated published ports", () => {
+    commandExists.mockReturnValue(true);
+    execCommand.mockImplementation((c: string) =>
+      c === "docker ps -q"
+        ? "abc\ndef\nghi"
+        : [
+            "web\t0.0.0.0:8080->80/tcp, :::8080->80/tcp, 0.0.0.0:9000-9002->9000-9002/tcp",
+            "db\t5432/tcp",
+            "bare",
+            "\t0.0.0.0:1->1/tcp",
+          ].join("\n"),
+    );
+    const c = ctx();
+    expect(s.containers(c)).toBe("web 80 9000-9002 db bare");
+    execCommand.mockReturnValue("");
+    expect(s.containers(c)).toBe("web 80 9000-9002 db bare");
+  });
+
+  it("is empty when docker errors", () => {
+    commandExists.mockReturnValue(true);
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(s.containers(ctx())).toBe("");
+  });
+});

package/src/info/software.ts

@@ -185,7 +185,7 @@ export function containers(context: InfoContext): string {
           if (portMatches) {
             const uniquePorts = [
               ...new Set(
-                portMatches.map((p) => p.replace(/->\d+(-\d+)?\//, ""))
+                portMatches.map((p) => p.replace(/^->(\d+(-\d+)?)\/$/, "$1"))
               ),
             ];
             containerInfo.push(...uniquePorts);

package/src/info/system-status.test.ts

@@ -0,0 +1,207 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const flags = vi.hoisted(() => ({ linux: true, mac: false }));
+vi.mock("../utils/platform", () => ({
+  get IS_LINUX() {
+    return flags.linux;
+  },
+  get IS_MAC() {
+    return flags.mac;
+  },
+  IS_WINDOWS: false,
+}));
+
+const execCommand = vi.hoisted(() => vi.fn());
+const commandExists = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists }));
+
+const files = vi.hoisted(() => ({ map: {} as Record<string, string> }));
+const fsMock = vi.hoisted(() => ({
+  existsSync: vi.fn((p: string) => p in files.map),
+  readFileSync: vi.fn((p: string) => {
+    if (!(p in files.map)) throw new Error("ENOENT");
+    return files.map[p];
+  }),
+  writeFileSync: vi.fn(),
+}));
+vi.mock("fs", () => ({ ...fsMock, default: fsMock }));
+
+const osMock = vi.hoisted(() => ({
+  loadavg: vi.fn(() => [0.5, 1.25, 2]),
+  tmpdir: vi.fn(() => "/tmp"),
+  platform: vi.fn(() => "linux"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const st = await import("./system-status");
+import type { InfoContext } from "../types/internal-types";
+
+const ctx = (): InfoContext => ({ cache: {} });
+const platform = (v: "linux" | "mac" | "other") => {
+  flags.linux = v === "linux";
+  flags.mac = v === "mac";
+};
+
+beforeEach(() => {
+  platform("linux");
+  files.map = {};
+  execCommand.mockReset().mockReturnValue("");
+  commandExists.mockReset().mockReturnValue(false);
+});
+
+describe("load_average", () => {
+  it("reads /proc/loadavg on Linux", () => {
+    files.map["/proc/loadavg"] = "0.10 0.20 0.30 1/200 999";
+    expect(st.load_average(ctx())).toBe("0.10 0.20 0.30");
+  });
+
+  it("is empty when /proc/loadavg is unreadable", () => {
+    expect(st.load_average(ctx())).toBe("");
+  });
+
+  it("formats os.loadavg on macOS", () => {
+    platform("mac");
+    expect(st.load_average(ctx())).toBe("0.50 1.25 2.00");
+  });
+
+  it("is empty on other platforms", () => {
+    platform("other");
+    expect(st.load_average(ctx())).toBe("");
+  });
+});
+
+describe("battery", () => {
+  it("reads capacity/status from sysfs on Linux", () => {
+    files.map["/sys/class/power_supply/BAT0/capacity"] = "87\n";
+    files.map["/sys/class/power_supply/BAT0/status"] = "Charging\n";
+    expect(st.battery(ctx())).toBe("87%+");
+  });
+
+  it("omits the + when discharging, or when status is unavailable", () => {
+    files.map["/sys/class/power_supply/BAT0/capacity"] = "50";
+    files.map["/sys/class/power_supply/BAT0/status"] = "Discharging";
+    expect(st.battery(ctx())).toBe("50%");
+    delete files.map["/sys/class/power_supply/BAT0/status"];
+    expect(st.battery(ctx())).toBe("50%");
+  });
+
+  it("is empty with no battery", () => {
+    expect(st.battery(ctx())).toBe("");
+  });
+
+  it("parses pmset on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue("Now drawing from 'AC Power'\n -InternalBattery-0 (id=1)\t64%; charging; 1:00 remaining");
+    expect(st.battery(ctx())).toBe("64%+");
+    execCommand.mockReturnValue("-InternalBattery-0\t64%; discharging; 3:00 remaining");
+    expect(st.battery(ctx())).toBe("64%");
+    execCommand.mockReturnValue("No batteries");
+    expect(st.battery(ctx())).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(st.battery(ctx())).toBe("");
+  });
+
+  it("is empty on other platforms, and cached", () => {
+    platform("other");
+    const c = ctx();
+    expect(st.battery(c)).toBe("");
+    platform("linux");
+    files.map["/sys/class/power_supply/BAT0/capacity"] = "10";
+    expect(st.battery(c)).toBe("");
+  });
+});
+
+describe("temperature", () => {
+  it("reads the first plausible sysfs thermal source", () => {
+    files.map["/sys/class/thermal/thermal_zone0/temp"] = "0";
+    files.map["/sys/class/hwmon/hwmon0/temp1_input"] = "54321";
+    expect(st.temperature(ctx())).toBe("54°C");
+  });
+
+  it("rejects implausible readings", () => {
+    files.map["/sys/class/thermal/thermal_zone0/temp"] = "200000";
+    expect(st.temperature(ctx())).toBe("");
+  });
+
+  it("is empty when no sensors exist", () => {
+    expect(st.temperature(ctx())).toBe("");
+  });
+
+  it("uses osx-cpu-temp on macOS when installed", () => {
+    platform("mac");
+    commandExists.mockReturnValue(true);
+    execCommand.mockReturnValue("61.7°C");
+    expect(st.temperature(ctx())).toBe("62°C");
+    execCommand.mockReturnValue("999.0°C");
+    expect(st.temperature(ctx())).toBe("");
+    execCommand.mockReturnValue("no temp");
+    expect(st.temperature(ctx())).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(st.temperature(ctx())).toBe("");
+  });
+
+  it("is empty on macOS without osx-cpu-temp and on other platforms", () => {
+    platform("mac");
+    expect(st.temperature(ctx())).toBe("");
+    platform("other");
+    expect(st.temperature(ctx())).toBe("");
+  });
+
+  it("serves from the cache", () => {
+    const c = ctx();
+    files.map["/sys/class/thermal/thermal_zone0/temp"] = "40000";
+    expect(st.temperature(c)).toBe("40°C");
+    files.map["/sys/class/thermal/thermal_zone0/temp"] = "90000";
+    expect(st.temperature(c)).toBe("40°C");
+  });
+});
+
+describe("services_running", () => {
+  it("counts running units via systemctl", () => {
+    commandExists.mockImplementation((c: string) => c === "systemctl");
+    execCommand.mockReturnValue("a.service loaded active running A\nb.service loaded active running B\nfooter");
+    expect(st.services_running(ctx())).toBe("2 services");
+  });
+
+  it("falls back to `service --status-all`", () => {
+    commandExists.mockImplementation((c: string) => c === "service");
+    execCommand.mockReturnValue(" [ + ]  cron\n [ - ]  nginx\n [ + ]  ssh");
+    expect(st.services_running(ctx())).toBe("2 services");
+  });
+
+  it("is empty with no service manager, zero services, or on error", () => {
+    expect(st.services_running(ctx())).toBe("");
+    commandExists.mockReturnValue(true);
+    execCommand.mockReturnValue("");
+    expect(st.services_running(ctx())).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(st.services_running(ctx())).toBe("");
+  });
+
+  it("counts launchctl entries on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue("PID Status Label\n1 0 com.a\n- 0 com.b\n\n");
+    expect(st.services_running(ctx())).toBe("2 services");
+    execCommand.mockReturnValue("PID Status Label");
+    expect(st.services_running(ctx())).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(st.services_running(ctx())).toBe("");
+  });
+
+  it("is empty on other platforms, and cached", () => {
+    platform("other");
+    const c = ctx();
+    expect(st.services_running(c)).toBe("");
+    platform("mac");
+    execCommand.mockReturnValue("PID\n1 0 a");
+    expect(st.services_running(c)).toBe("");
+  });
+});