about-system 0.0.51 → 0.0.66

package/dist/system-info-api.js

@@ -2,7 +2,7 @@ import "os";
 import "fs";
 import "https";
 import "path";
-import { g as m, i as r, l as p, s as n } from "./system-info-api-CChFyamn.js";
+import { g as m, i as r, l as p, s as n } from "./system-info-api-C_y-O4VW.js";
 export {
   m as getSystemInfo,
   r as infoFunctions,

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "about-system",
-  "version": "0.0.51",
+  "version": "0.0.66",
   "description": "A Node.js script to display key system information with emojis. Cross-platform support for Windows, macOS, and Linux with customizable output and caching.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "about-system": "./dist/about-system-cli.js"
+    "about-system": "dist/about-system-cli.js"
   },
   "type": "module",
   "exports": {
@@ -35,7 +35,13 @@
     "show-settings": "npm run build && node dist/about-system-cli.js --settings-show",
     "reset-settings": "npm run build && node dist/about-system-cli.js --settings-reset",
     "clear-cache": "npm run build && node dist/about-system-cli.js --refresh",
-    "help": "npm run build && node dist/about-system-cli.js --help"
+    "help": "npm run build && node dist/about-system-cli.js --help",
+    "app:dev": "cd native && npm run dev",
+    "app:build": "cd native && npm run build:desktop",
+    "test": "vitest run",
+    "test:ci": "vitest run --reporter=junit --outputFile=./junit.xml --coverage --coverage.reporter=lcov",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage"
   },
   "keywords": [
     "src/about-system",
@@ -50,13 +56,16 @@
     "shell",
     "greeting",
     "emoji",
-    "system-monitoring"
+    "system-monitoring",
+    "desktop-app",
+    "tauri"
   ],
   "author": "vtempest",
   "license": "rights.institute/prosper",
   "repository": {
     "type": "git",
-    "url": "https://github.com/OpenSourceAGI/dev-tools-starter-agent/tree/master/packages/about-system-info"
+    "url": "git+https://github.com/OpenSourceAGI/dev-tools-starter-agent.git",
+    "directory": "packages/about-system-info"
   },
   "homepage": "https://github.com/OpenSourceAGI/dev-tools-starter-agent/tree/master/packages/about-system-info",
   "files": [
@@ -81,8 +90,10 @@
   },
   "devDependencies": {
     "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.1.0",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
-    "vite-plugin-dts": "^4.5.4"
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.1.0"
   }
 }

package/src/about-system-cli.ts

@@ -12,6 +12,7 @@ import {
   Settings,
   DEFAULT_SETTINGS,
   colors,
+  backgrounds,
   SETTINGS_FILE,
   CACHE_FILE,
   loadSettings,
@@ -21,11 +22,25 @@ import {
 // Platform detection
 const IS_WINDOWS = os.platform() === "win32";
 
+// Foreground code -> [background code, contrasting text code] for the
+// legacy 8-color multicolor rotation (ports/pacman rainbow mode).
+const MULTICOLOR_BG: Record<number, [number, number]> = {
+  31: [41, 97], // red
+  32: [42, 30], // green
+  33: [43, 30], // yellow
+  34: [44, 97], // blue
+  35: [45, 97], // magenta
+  36: [46, 30], // cyan
+};
+
 function formatValue(key: string, value: string, settings: Settings): string {
   if (!value || value.trim() === "") return "";
 
-  const color =
-    colors[settings.colors[key] as keyof typeof colors] || colors.reset;
+  const showBackgrounds = settings.display.show_backgrounds !== false;
+  const colorName = settings.colors[key] as keyof typeof colors;
+  const bg = backgrounds[colorName as keyof typeof backgrounds];
+  const style = (showBackgrounds && bg) || colors[colorName] || colors.reset;
+  const suffix = showBackgrounds ? colors.reset : "";
   const emoji = settings.display.show_emojis ? settings.emojis[key] || "" : "";
 
   // Special handling for battery emoji
@@ -33,7 +48,7 @@ function formatValue(key: string, value: string, settings: Settings): string {
     const batteryEmoji = value.includes("+")
       ? settings.emojis.battery_charging
       : settings.emojis.battery;
-    return `${color}${batteryEmoji}${value}`;
+    return `${style}${batteryEmoji}${value}${suffix}`;
   }
 
   // Multicolor handling for ports
@@ -44,7 +59,12 @@ function formatValue(key: string, value: string, settings: Settings): string {
     const colorCodes = [31, 32, 33, 34, 35, 36];
     ports.forEach((port, index) => {
       const colorCode = colorCodes[index % colorCodes.length];
-      output += `\x1b[${colorCode}m${port}\x1b[0m `;
+      if (showBackgrounds) {
+        const [bgCode, textCode] = MULTICOLOR_BG[colorCode];
+        output += `\x1b[${bgCode}m\x1b[${textCode}m${port}\x1b[0m `;
+      } else {
+        output += `\x1b[${colorCode}m${port}\x1b[0m `;
+      }
     });
     return output.trim();
   }
@@ -52,10 +72,10 @@ function formatValue(key: string, value: string, settings: Settings): string {
   // Multicolor handling for pacman
   if (key === "pacman" && settings.colors[key] === "multicolor" && value) {
     const emoji = settings.display.show_emojis ? settings.emojis.pacman : "";
-    return `${color}${emoji}${value}`;
+    return `${style}${emoji}${value}${suffix}`;
   }
 
-  return `${color}${emoji}${value}`;
+  return `${style}${emoji}${value}${suffix}`;
 }
 
 /**
@@ -230,6 +250,10 @@ function handleSettingsCommand(args: string[]): boolean {
       const parsedValue =
         value.startsWith("{") || value.startsWith("[")
           ? JSON.parse(value)
+          : value === "true"
+          ? true
+          : value === "false"
+          ? false
           : value;
 
       const keys = key.split(".");
@@ -400,6 +424,7 @@ Examples:
   about-system disk_used            # Show only disk usage
   about-system --install
   about-system --set display.show_emojis false
+  about-system --set display.show_backgrounds false
   about-system --set colors.user blue
   about-system --set emojis.cpu "🚀 "
   about-system --set labels.cpu "Processor"

package/src/cache/cache.test.ts

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview Covers the on-disk cache that keeps `about-system` fast: most
+ * of the facts it reports are expensive to collect (shelling out to `wmic`,
+ * `sw_vers`, `lspci`) and change rarely, so a stale-but-valid entry is the
+ * difference between an instant readout and a multi-second one.
+ *
+ * The behaviours worth pinning are the ones that decide whether a user sees
+ * anything at all: a corrupt cache file must not throw, an unwritable temp
+ * directory must not throw, and an expired entry must never be served.
+ */
+
+import fs from "fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  type Cache,
+  getCachedValue,
+  isCacheValid,
+  loadCache,
+  saveCache,
+  setCachedValue,
+} from "./cache";
+import { CACHE_DURATION, CACHE_FILE } from "./cache-config";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("loadCache", () => {
+  it("returns an empty cache when no file exists yet", () => {
+    vi.spyOn(fs, "existsSync").mockReturnValue(false);
+    expect(loadCache()).toEqual({});
+  });
+
+  it("reads a previously saved cache back", () => {
+    const stored: Cache = { cpu: { value: "M2 Pro", timestamp: 123 } };
+    vi.spyOn(fs, "existsSync").mockReturnValue(true);
+    vi.spyOn(fs, "readFileSync").mockReturnValue(JSON.stringify(stored));
+
+    expect(loadCache()).toEqual(stored);
+  });
+
+  it("reads from the temp-directory cache file", () => {
+    vi.spyOn(fs, "existsSync").mockReturnValue(true);
+    const read = vi.spyOn(fs, "readFileSync").mockReturnValue("{}");
+
+    loadCache();
+
+    expect(read).toHaveBeenCalledWith(CACHE_FILE, "utf8");
+  });
+
+  it("recovers from a corrupt cache file rather than throwing", () => {
+    vi.spyOn(fs, "existsSync").mockReturnValue(true);
+    vi.spyOn(fs, "readFileSync").mockReturnValue("{ not json");
+
+    expect(loadCache()).toEqual({});
+  });
+
+  it("recovers from an unreadable cache file", () => {
+    vi.spyOn(fs, "existsSync").mockReturnValue(true);
+    vi.spyOn(fs, "readFileSync").mockImplementation(() => {
+      throw new Error("EACCES");
+    });
+
+    expect(loadCache()).toEqual({});
+  });
+});
+
+describe("saveCache", () => {
+  it("writes the cache as readable json", () => {
+    const write = vi.spyOn(fs, "writeFileSync").mockImplementation(() => {});
+    const cache: Cache = { cpu: { value: "M2 Pro", timestamp: 1 } };
+
+    saveCache(cache);
+
+    expect(write).toHaveBeenCalledWith(
+      CACHE_FILE,
+      JSON.stringify(cache, null, 2),
+    );
+  });
+
+  it("stays silent when the cache file cannot be written", () => {
+    vi.spyOn(fs, "writeFileSync").mockImplementation(() => {
+      throw new Error("EROFS");
+    });
+
+    expect(() => saveCache({})).not.toThrow();
+  });
+});
+
+describe("isCacheValid", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1_000_000);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("accepts an entry written just now", () => {
+    expect(isCacheValid({ value: "x", timestamp: Date.now() }, "cpu")).toBe(true);
+  });
+
+  it("rejects an entry older than its key's duration", () => {
+    const timestamp = Date.now() - CACHE_DURATION.ram_used - 1;
+    expect(isCacheValid({ value: "x", timestamp }, "ram_used")).toBe(false);
+  });
+
+  it("uses each key's own duration, not one global one", () => {
+    // A minute-old entry is stale for RAM (10s) but fresh for the CPU (24h).
+    const timestamp = Date.now() - 60_000;
+    expect(isCacheValid({ value: "x", timestamp }, "ram_used")).toBe(false);
+    expect(isCacheValid({ value: "x", timestamp }, "cpu")).toBe(true);
+  });
+
+  it("falls back to a one-minute window for an unknown key", () => {
+    expect(
+      isCacheValid({ value: "x", timestamp: Date.now() - 59_000 }, "unknown"),
+    ).toBe(true);
+    expect(
+      isCacheValid({ value: "x", timestamp: Date.now() - 61_000 }, "unknown"),
+    ).toBe(false);
+  });
+
+  it.each([
+    [undefined, "missing"],
+    [null, "null"],
+    [{ value: "x" }, "timestamp-less"],
+    [{ value: "x", timestamp: 0 }, "zero-timestamped"],
+  ])("rejects a %s entry", (entry) => {
+    expect(isCacheValid(entry as never, "cpu")).toBe(false);
+  });
+});
+
+describe("getCachedValue", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1_000_000);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("returns null for a key that was never cached", () => {
+    expect(getCachedValue({}, "cpu")).toBeNull();
+  });
+
+  it("returns a fresh value", () => {
+    const cache: Cache = { cpu: { value: "M2 Pro", timestamp: Date.now() } };
+    expect(getCachedValue(cache, "cpu")).toBe("M2 Pro");
+  });
+
+  it("returns a cached falsy value rather than mistaking it for a miss", () => {
+    const cache: Cache = { battery: { value: 0, timestamp: Date.now() } };
+    expect(getCachedValue(cache, "battery")).toBe(0);
+  });
+
+  it("returns null for an expired value", () => {
+    const cache: Cache = {
+      ram_used: { value: "8 GB", timestamp: Date.now() - 60_000 },
+    };
+    expect(getCachedValue(cache, "ram_used")).toBeNull();
+  });
+
+  it("evicts an expired entry so it is not re-checked", () => {
+    const cache: Cache = {
+      ram_used: { value: "8 GB", timestamp: Date.now() - 60_000 },
+    };
+
+    getCachedValue(cache, "ram_used");
+
+    expect(cache).not.toHaveProperty("ram_used");
+  });
+
+  it("keeps a fresh entry in place", () => {
+    const cache: Cache = { cpu: { value: "M2 Pro", timestamp: Date.now() } };
+    getCachedValue(cache, "cpu");
+    expect(cache).toHaveProperty("cpu");
+  });
+});
+
+describe("setCachedValue", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1_000_000);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("stamps the value with the time it was cached", () => {
+    const cache: Cache = {};
+    setCachedValue(cache, "cpu", "M2 Pro");
+
+    expect(cache.cpu).toEqual({ value: "M2 Pro", timestamp: 1_000_000 });
+  });
+
+  it("round-trips through getCachedValue", () => {
+    const cache: Cache = {};
+    setCachedValue(cache, "cpu", "M2 Pro");
+    expect(getCachedValue(cache, "cpu")).toBe("M2 Pro");
+  });
+
+  it("replaces an existing entry and refreshes its timestamp", () => {
+    const cache: Cache = { cpu: { value: "old", timestamp: 1 } };
+    setCachedValue(cache, "cpu", "new");
+
+    expect(cache.cpu).toEqual({ value: "new", timestamp: 1_000_000 });
+  });
+
+  it("stores structured values, not just strings", () => {
+    const cache: Cache = {};
+    setCachedValue(cache, "network_interfaces", [{ name: "en0" }]);
+
+    expect(getCachedValue(cache, "network_interfaces")).toEqual([
+      { name: "en0" },
+    ]);
+  });
+});
+
+describe("CACHE_DURATION", () => {
+  it("gives every cached key a positive window", () => {
+    for (const [key, duration] of Object.entries(CACHE_DURATION)) {
+      expect(duration, key).toBeGreaterThan(0);
+    }
+  });
+
+  it("caches volatile readings for less time than fixed hardware facts", () => {
+    expect(CACHE_DURATION.ram_used).toBeLessThan(CACHE_DURATION.cpu);
+    expect(CACHE_DURATION.top_process).toBeLessThan(CACHE_DURATION.os);
+  });
+});

package/src/info/platform.test.ts

@@ -0,0 +1,190 @@
+/**
+ * @fileoverview Covers the platform facts `about-system` opens its readout
+ * with: user, hostname, OS name, kernel and device model.
+ *
+ * Each of these shells out to a different tool per platform and parses its
+ * output, so the tests drive the Linux path (the one CI runs on) end to end and
+ * pin the two behaviours that hold everywhere: the cache is consulted before
+ * any command runs, and a missing tool degrades to a fallback rather than
+ * throwing.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// These modules bind their imports by name, so the dependencies have to be
+// mocked outright rather than spied on through a namespace object.
+const execCommand = vi.hoisted(() => vi.fn());
+const commandExists = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists }));
+
+const osMock = vi.hoisted(() => ({
+  platform: vi.fn(() => "linux"),
+  release: vi.fn(() => "6.1.0-generic"),
+  hostname: vi.fn(() => "workstation"),
+  userInfo: vi.fn(() => ({ username: "ada" })),
+  // cache-config resolves the cache file under the temp directory at import time.
+  tmpdir: vi.fn(() => "/tmp"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const fsMock = vi.hoisted(() => ({
+  existsSync: vi.fn(() => false),
+  readFileSync: vi.fn(() => ""),
+}));
+vi.mock("fs", () => ({ ...fsMock, default: fsMock }));
+
+const { device, hostname, kernel, os_info, user } = await import("./platform");
+const { IS_LINUX } = await import("../utils/platform");
+import type { InfoContext } from "../types/internal-types";
+
+const context = (): InfoContext => ({ cache: {} });
+
+beforeEach(() => {
+  execCommand.mockReturnValue("");
+  commandExists.mockReturnValue(false);
+  fsMock.existsSync.mockReturnValue(false);
+  fsMock.readFileSync.mockReturnValue("");
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("user and hostname", () => {
+  it("reads the current username", () => {
+    expect(user()).toBe("ada");
+  });
+
+  it("reads the machine's network name", () => {
+    expect(hostname()).toBe("workstation");
+  });
+});
+
+describe("kernel", () => {
+  it("reports the kernel release", () => {
+    expect(kernel(context())).toBe("6.1.0-generic");
+  });
+
+  it("caches the result", () => {
+    const ctx = context();
+    kernel(ctx);
+    expect(ctx.cache.kernel?.value).toBe("6.1.0-generic");
+  });
+
+  it("serves a cached kernel without asking the OS again", () => {
+    const ctx = context();
+    ctx.cache.kernel = { value: "cached-kernel", timestamp: Date.now() };
+
+    expect(kernel(ctx)).toBe("cached-kernel");
+    expect(osMock.release).not.toHaveBeenCalled();
+  });
+});
+
+describe("os_info", () => {
+  it("serves a cached value without running any command", () => {
+    const ctx = context();
+    ctx.cache.os = { value: "Cached OS 1.0", timestamp: Date.now() };
+
+    expect(os_info(ctx)).toBe("Cached OS 1.0");
+    expect(execCommand).not.toHaveBeenCalled();
+  });
+
+  it("caches whatever it resolves", () => {
+    const ctx = context();
+    const resolved = os_info(ctx);
+    expect(ctx.cache.os?.value).toBe(resolved);
+  });
+
+  it("never returns an empty string, whatever the platform", () => {
+    expect(os_info(context())).toBeTruthy();
+  });
+
+  it.runIf(IS_LINUX)("reads the distribution from /etc/os-release", () => {
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.readFileSync.mockReturnValue(
+      'NAME="Ubuntu"\nVERSION_ID="22.04"\nID=ubuntu\n',
+    );
+
+    expect(os_info(context())).toBe("Ubuntu 22.04");
+  });
+
+  it.runIf(IS_LINUX)("uses the name alone when there is no version id", () => {
+    fsMock.readFileSync.mockReturnValue('NAME="Arch Linux"\n');
+    expect(os_info(context())).toBe("Arch Linux");
+  });
+
+  it.runIf(IS_LINUX)("falls back to the kernel release with no os-release file", () => {
+    fsMock.readFileSync.mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+
+    expect(os_info(context())).toBe("Linux 6.1.0-generic");
+  });
+
+  it.runIf(IS_LINUX)("falls back to a bare Linux when the file has no NAME", () => {
+    fsMock.readFileSync.mockReturnValue("ID=unknown\n");
+    expect(os_info(context())).toBe("Linux");
+  });
+});
+
+describe("device", () => {
+  it("serves a cached model without probing", () => {
+    const ctx = context();
+    ctx.cache.device = { value: "Cached Box", timestamp: Date.now() };
+
+    expect(device(ctx)).toBe("Cached Box");
+    expect(execCommand).not.toHaveBeenCalled();
+  });
+
+  it("caches an empty result too, so the probe is not repeated", () => {
+    const ctx = context();
+    device(ctx);
+    expect(ctx.cache.device).toBeDefined();
+  });
+
+  it("returns an empty string when nothing identifies the machine", () => {
+    expect(device(context())).toBe("");
+  });
+
+  it.runIf(IS_LINUX)("reads the model from the DMI product name", () => {
+    fsMock.existsSync.mockImplementation(
+      (path: string) => path === "/sys/devices/virtual/dmi/id/product_name",
+    );
+    fsMock.readFileSync.mockReturnValue("OptiPlex 7090\n");
+
+    expect(device(context())).toBe("OptiPlex 7090");
+  });
+
+  it.runIf(IS_LINUX)("prefers Android's getprop when it is available", () => {
+    commandExists.mockImplementation((cmd: string) => cmd === "getprop");
+    execCommand.mockReturnValue("Pixel 8");
+
+    expect(device(context())).toBe("Pixel 8");
+    expect(execCommand).toHaveBeenCalledWith("getprop ro.product.model");
+  });
+
+  it.runIf(IS_LINUX)("falls through to DMI when getprop answers nothing", () => {
+    commandExists.mockImplementation((cmd: string) => cmd === "getprop");
+    execCommand.mockReturnValue("");
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.readFileSync.mockReturnValue("Steam Deck\n");
+
+    expect(device(context())).toBe("Steam Deck");
+  });
+
+  it.runIf(IS_LINUX)("ignores a blank DMI product name", () => {
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.readFileSync.mockReturnValue("   \n");
+
+    expect(device(context())).toBe("");
+  });
+
+  it.runIf(IS_LINUX)("survives an unreadable DMI file", () => {
+    fsMock.existsSync.mockReturnValue(true);
+    fsMock.readFileSync.mockImplementation(() => {
+      throw new Error("EACCES");
+    });
+
+    expect(device(context())).toBe("");
+  });
+});

package/src/info/settings.ts

@@ -17,18 +17,43 @@ export const SETTINGS_FILE = path.join(
 export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
 
 // Color codes
+//
+// These are deliberately darker/more saturated than a typical terminal
+// palette. The original bright variants (e.g. yellow 226, cyan 51, gray 250)
+// have very high luminance and are nearly unreadable on a light/white
+// terminal background. `lightblue` was also mislabeled: it pointed at gold
+// (220), not a blue at all. Every value below reads clearly on both light
+// and dark backgrounds.
 export const colors = {
   reset: "\x1b[0m",
-  red: "\x1b[38;5;196m",
-  orange: "\x1b[38;5;208m",
-  yellow: "\x1b[38;5;226m",
-  green: "\x1b[38;5;46m",
-  blue: "\x1b[38;5;39m",
-  cyan: "\x1b[38;5;51m",
-  purple: "\x1b[38;5;171m",
-  magenta: "\x1b[38;5;213m",
-  gray: "\x1b[38;5;250m",
-  lightblue: "\x1b[38;5;220m",
+  red: "\x1b[38;5;160m",
+  orange: "\x1b[38;5;130m",
+  yellow: "\x1b[38;5;58m",
+  green: "\x1b[38;5;22m",
+  blue: "\x1b[38;5;25m",
+  cyan: "\x1b[38;5;23m",
+  purple: "\x1b[38;5;91m",
+  magenta: "\x1b[38;5;125m",
+  gray: "\x1b[38;5;238m",
+  lightblue: "\x1b[38;5;24m",
+};
+
+// Background variants, keyed the same as `colors`, used when
+// `display.show_backgrounds` is enabled. Each entry sets its own background
+// block plus a foreground text color chosen for contrast against it, so
+// every item is legible on its own regardless of what the terminal's
+// background actually is.
+export const backgrounds = {
+  red: "\x1b[48;5;88m\x1b[38;5;255m",
+  orange: "\x1b[48;5;166m\x1b[38;5;232m",
+  yellow: "\x1b[48;5;178m\x1b[38;5;232m",
+  green: "\x1b[48;5;22m\x1b[38;5;255m",
+  blue: "\x1b[48;5;18m\x1b[38;5;255m",
+  cyan: "\x1b[48;5;23m\x1b[38;5;255m",
+  purple: "\x1b[48;5;54m\x1b[38;5;255m",
+  magenta: "\x1b[48;5;53m\x1b[38;5;255m",
+  gray: "\x1b[48;5;236m\x1b[38;5;255m",
+  lightblue: "\x1b[48;5;26m\x1b[38;5;255m",
 };
 
 // Default settings
@@ -154,6 +179,7 @@ export const DEFAULT_SETTINGS = {
   },
   display: {
     show_emojis: true,
+    show_backgrounds: true,
     single_line: true,
     line_wrap_length: process?.stdout?.columns || 100,
   },
@@ -172,6 +198,8 @@ export interface Settings {
   labels: Record<string, string>;
   display: {
     show_emojis: boolean;
+    /** true (default): give every item its own background color block, so it stays legible regardless of the terminal's background */
+    show_backgrounds: boolean;
     /** true: print one continuous line and let the terminal soft-wrap it; false: hard-wrap at line_wrap_length */
     single_line: boolean;
     line_wrap_length: number;