about-system 0.10.9 → 0.10.11

package/dist/system-info-api.d.ts

@@ -27,13 +27,6 @@ declare interface Cache {
     [key: string]: CacheEntry;
 }
 
-/**
- * Cache storage structure
- */
-declare interface Cache_2 {
-    [key: string]: CacheEntry_2;
-}
-
 /**
  * Cache management utilities
  * @module cache
@@ -49,21 +42,13 @@ declare interface CacheEntry {
     timestamp: number;
 }
 
-/**
- * Represents a cached value with timestamp
- */
-declare interface CacheEntry_2 {
-    value: any;
-    timestamp: number;
-}
-
 /**
  * Gets geographic city based on public IP
  * @param context - Info context with IP geolocation data
  * @returns City name or empty string
  * @example "San Francisco", "New York", "London"
  */
-declare function city(context: InfoContext): Promise<string>;
+declare function city(context: InfoContext): string;
 
 /**
  * Gets running Docker container names
@@ -131,10 +116,14 @@ declare function disk_used(context: InfoContext): string;
  * @returns Domain with http:// prefix or empty string
  * @example "http://example.com", "http://host-203-0-113-42.example.net"
  */
-declare function domain(context: InfoContext): Promise<string>;
+declare function domain(context: InfoContext): string;
 
 /**
- * Get all system information as a clean JSON object
+ * Get system information as a clean JSON object.
+ *
+ * `options.keys` limits collection to those blocks (all by default).
+ * `options.signal` stops collection early: whatever was gathered before the
+ * abort is returned, and the remaining blocks are left out.
  */
 export declare function getSystemInfo(options?: SystemInfoOptions): Promise<SystemInfo>;
 
@@ -225,12 +214,13 @@ export declare const infoFunctions: {
 };
 
 /**
- * Gets public IP address from ipinfo.io
- * @param context - Info context with cache and IP info
- * @returns Public IPv4 address or empty string
+ * Gets public IP address. The ip, city, domain and isp blocks all read the one
+ * shared lookup in `context.ipInfo`, which `getSystemInfo` caches for 10 minutes.
+ * @param context - Info context with IP info
+ * @returns Public IP address or empty string
  * @example "203.0.113.42"
  */
-declare function ip(context: InfoContext): Promise<string>;
+declare function ip(context: InfoContext): string;
 
 /**
  * Network utilities for IP information fetching
@@ -266,7 +256,7 @@ declare function iplocal(): string;
  * @returns ISP name or empty string
  * @example "Comcast Cable", "Verizon Business", "Cloudflare Inc"
  */
-declare function isp(context: InfoContext): Promise<string>;
+declare function isp(context: InfoContext): string;
 
 /**
  * Gets kernel version string
@@ -289,7 +279,7 @@ declare function load_average(context: InfoContext): string;
 /**
  * Loads cache from disk
  */
-export declare function loadCache(): Cache_2;
+export declare function loadCache(): Cache;
 
 /**
  * Gets available memory in gigabytes
@@ -361,7 +351,7 @@ declare function ram_used(context: InfoContext): string;
 /**
  * Saves cache to disk
  */
-export declare function saveCache(cache: Cache_2): void;
+export declare function saveCache(cache: Cache): void;
 
 /**
  * Gets screen resolution

package/dist/system-info-api.js

@@ -1,12 +1,11 @@
 import "os";
 import "fs";
-import "https";
+import { g as i, i as m, l as r, s as n } from "./system-info-api-D85U-_0W.js";
 import "path";
-import { g as m, i as r, l as p, s as n } from "./system-info-api-NgTm8Gzo.js";
 export {
-  m as getSystemInfo,
-  r as infoFunctions,
-  p as loadCache,
+  i as getSystemInfo,
+  m as infoFunctions,
+  r as loadCache,
   n as saveCache
 };
 //# sourceMappingURL=system-info-api.js.map

package/dist/system-info-api.js.map

@@ -1 +1 @@
-{"version":3,"file":"system-info-api.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}
+{"version":3,"file":"system-info-api.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "about-system",
-  "version": "0.10.9",
+  "version": "0.10.11",
   "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",

package/src/about-system-cli.ts

@@ -146,14 +146,51 @@ function wrapAnsiText(text: string, maxLength: number): string[] {
   return lines;
 }
 
+/**
+ * Collects system info, stopping early when Esc is pressed. On Esc the blocks
+ * gathered so far are returned and the rest are skipped. Only listens when
+ * stdin is an interactive terminal; raw mode swallows Ctrl+C, so that is
+ * handled here too.
+ */
+async function collectSystemInfo(keys?: string[]): Promise<SystemInfo> {
+  const controller = new AbortController();
+  const stdin = process.stdin;
+  const listen = stdin.isTTY && typeof stdin.setRawMode === "function";
+
+  const stopListening = () => {
+    stdin.off("data", onKey);
+    stdin.setRawMode(false);
+    stdin.pause();
+  };
+  const onKey = (data: Buffer) => {
+    // A lone ESC byte; arrow keys etc. arrive as longer ESC sequences.
+    if (data.length === 1 && data[0] === 0x1b) controller.abort();
+    else if (data.includes(0x03)) {
+      stopListening();
+      process.exit(130);
+    }
+  };
+
+  if (listen) {
+    stdin.setRawMode(true);
+    stdin.on("data", onKey);
+    stdin.resume();
+  }
+  try {
+    return await getSystemInfo({ keys, signal: controller.signal });
+  } finally {
+    if (listen) stopListening();
+  }
+}
+
 async function displaySystemInfo(
   customDisplayOrder: string[][] | null = null
 ): Promise<void> {
   const settings = loadSettings();
   const displayOrder = customDisplayOrder || settings.display_order;
 
-  // Get system info
-  const info = await getSystemInfo();
+  // Get only the blocks that will be shown
+  const info = await collectSystemInfo(displayOrder.flat());
 
   // Single line mode
   if (settings.display.single_line) {
@@ -446,6 +483,8 @@ Options:
   --set <key> <value>  Set a configuration value (use dot notation)
   --json               Output as JSON
 
+Press Esc while it runs to stop and print only what was collected so far.
+
 Examples:
   about-system                      # Show all info (default)
   about-system cpu,os               # Show only CPU and OS info
@@ -507,7 +546,7 @@ async function main(): Promise<void> {
   }
 
   if (args.includes("--json")) {
-    const info = await getSystemInfo();
+    const info = await collectSystemInfo();
     console.log(JSON.stringify(info, null, 2));
     return;
   }

package/src/cache/cache-config.ts

@@ -17,7 +17,7 @@ export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
  * Values are in milliseconds
  *
  * @constant
- * @property {number} ip - IP information cache (5 minutes)
+ * @property {number} ipInfo - Public IP / city / ISP lookup (10 minutes)
  * @property {number} cpu - CPU information cache (24 hours)
  * @property {number} gpu - GPU information cache (24 hours)
  * @property {number} os - OS information cache (24 hours)
@@ -36,7 +36,7 @@ export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
  * @property {number} mount_points - Mount points cache (10 minutes)
  */
 export const CACHE_DURATION = {
-  ip: 5 * 60 * 1000,
+  ipInfo: 10 * 60 * 1000,
   cpu: 24 * 60 * 60 * 1000,
   gpu: 24 * 60 * 60 * 1000,
   os: 24 * 60 * 60 * 1000,
@@ -65,4 +65,4 @@ export const DEFAULT_IPINFO_TOKEN = "da2d6cc4baa5d1";
  * Default network request timeout in milliseconds
  * @constant
  */
-export const DEFAULT_NETWORK_TIMEOUT = 5000;
+export const DEFAULT_NETWORK_TIMEOUT = 3000;

package/src/info/network.ts

@@ -10,22 +10,14 @@ import { execCommand } from "../utils/command";
 import { getCachedValue, setCachedValue } from "../cache/cache";
 
 /**
- * Gets public IP address from ipinfo.io
- * @param context - Info context with cache and IP info
- * @returns Public IPv4 address or empty string
+ * Gets public IP address. The ip, city, domain and isp blocks all read the one
+ * shared lookup in `context.ipInfo`, which `getSystemInfo` caches for 10 minutes.
+ * @param context - Info context with IP info
+ * @returns Public IP address or empty string
  * @example "203.0.113.42"
  */
-export async function ip(context: InfoContext): Promise<string> {
-  const cached = getCachedValue(context.cache, "ip");
-  if (cached) return cached;
-
-  if (!context.ipInfo) {
-    setCachedValue(context.cache, "ip", "");
-    return "";
-  }
-  const ip = context.ipInfo.ip || "";
-  setCachedValue(context.cache, "ip", ip);
-  return ip;
+export function ip(context: InfoContext): string {
+  return context.ipInfo?.ip || "";
 }
 
 /**
@@ -81,17 +73,8 @@ export function iplocal(): string {
  * @returns City name or empty string
  * @example "San Francisco", "New York", "London"
  */
-export async function city(context: InfoContext): Promise<string> {
-  const cached = getCachedValue(context.cache, "city");
-  if (cached !== null) return cached;
-
-  if (!context.ipInfo || !context.ipInfo.city) {
-    setCachedValue(context.cache, "city", "");
-    return "";
-  }
-  const city = context.ipInfo.city;
-  setCachedValue(context.cache, "city", city);
-  return city;
+export function city(context: InfoContext): string {
+  return context.ipInfo?.city || "";
 }
 
 /**
@@ -100,17 +83,9 @@ export async function city(context: InfoContext): Promise<string> {
  * @returns Domain with http:// prefix or empty string
  * @example "http://example.com", "http://host-203-0-113-42.example.net"
  */
-export async function domain(context: InfoContext): Promise<string> {
-  const cached = getCachedValue(context.cache, "domain");
-  if (cached !== null) return cached;
-
-  if (!context.ipInfo || !context.ipInfo.hostname) {
-    setCachedValue(context.cache, "domain", "");
-    return "";
-  }
-  const domain = `http://${context.ipInfo.hostname}`;
-  setCachedValue(context.cache, "domain", domain);
-  return domain;
+export function domain(context: InfoContext): string {
+  const hostname = context.ipInfo?.hostname;
+  return hostname ? `http://${hostname}` : "";
 }
 
 /**
@@ -120,17 +95,9 @@ export async function domain(context: InfoContext): Promise<string> {
  * @returns ISP name or empty string
  * @example "Comcast Cable", "Verizon Business", "Cloudflare Inc"
  */
-export async function isp(context: InfoContext): Promise<string> {
-  const cached = getCachedValue(context.cache, "isp");
-  if (cached !== null) return cached;
-
-  if (!context.ipInfo || !context.ipInfo.org) {
-    setCachedValue(context.cache, "isp", "");
-    return "";
-  }
-  const isp = context.ipInfo.org.split(" ").slice(1).join(" ");
-  setCachedValue(context.cache, "isp", isp);
-  return isp;
+export function isp(context: InfoContext): string {
+  const org = context.ipInfo?.org;
+  return org ? org.split(" ").slice(1).join(" ") : "";
 }
 
 /**

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

@@ -0,0 +1,106 @@
+/**
+ * @fileoverview Covers how getSystemInfo spends its time: only the requested
+ * blocks run, an abort returns what was gathered so far, and the public IP
+ * lookup hits the network at most once per 10 minutes.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const fetchIPInfo = vi.hoisted(() => vi.fn());
+vi.mock("./utils/network", () => ({ fetchIPInfo }));
+
+// Keep the on-disk cache in memory so tests don't touch the real temp file.
+const disk = vi.hoisted(() => ({ cache: undefined as string | undefined }));
+vi.mock("fs", async (importOriginal) => {
+  const real = await importOriginal<typeof import("fs")>();
+  const fake = {
+    ...real,
+    existsSync: (p: string) =>
+      String(p).endsWith("systeminfo-cache.json") ? disk.cache !== undefined : real.existsSync(p),
+    readFileSync: (p: string, ...rest: any[]) =>
+      String(p).endsWith("systeminfo-cache.json") ? disk.cache : (real.readFileSync as any)(p, ...rest),
+    writeFileSync: (p: string, data: string) => {
+      if (String(p).endsWith("systeminfo-cache.json")) disk.cache = data;
+    },
+    mkdirSync: () => undefined,
+  };
+  return { ...fake, default: fake };
+});
+
+import { getSystemInfo } from "./system-info-api";
+
+const TEN_MINUTES = 10 * 60 * 1000;
+
+beforeEach(() => {
+  disk.cache = undefined;
+  fetchIPInfo.mockResolvedValue({ ip: "203.0.113.7", city: "Oslo", org: "AS1 Example Net" });
+});
+
+afterEach(() => {
+  fetchIPInfo.mockReset();
+  vi.useRealTimers();
+});
+
+describe("getSystemInfo", () => {
+  it("collects only the requested blocks", async () => {
+    const info = await getSystemInfo({ keys: ["user", "hostname"] });
+
+    expect(Object.keys(info).sort()).toEqual(["hostname", "platform", "timestamp", "user"]);
+    expect(fetchIPInfo).not.toHaveBeenCalled();
+  });
+
+  it("derives ip, city and isp from one lookup", async () => {
+    const info = await getSystemInfo({ keys: ["ip", "city", "isp"] });
+
+    expect(info).toMatchObject({ ip: "203.0.113.7", city: "Oslo", isp: "Example Net" });
+    expect(fetchIPInfo).toHaveBeenCalledTimes(1);
+  });
+
+  it("reuses the IP lookup for 10 minutes, then refreshes it", async () => {
+    vi.useFakeTimers({ toFake: ["Date"] });
+
+    await getSystemInfo({ keys: ["ip"] });
+    vi.advanceTimersByTime(TEN_MINUTES - 1000);
+    await getSystemInfo({ keys: ["ip"] });
+    expect(fetchIPInfo).toHaveBeenCalledTimes(1);
+
+    vi.advanceTimersByTime(2000);
+    fetchIPInfo.mockResolvedValue({ ip: "198.51.100.9" });
+    const info = await getSystemInfo({ keys: ["ip"] });
+    expect(fetchIPInfo).toHaveBeenCalledTimes(2);
+    expect(info.ip).toBe("198.51.100.9");
+  });
+
+  it("keeps the last good IP when a refresh fails, and waits 10 minutes to retry", async () => {
+    vi.useFakeTimers({ toFake: ["Date"] });
+
+    await getSystemInfo({ keys: ["ip"] });
+    vi.advanceTimersByTime(TEN_MINUTES + 1000);
+    fetchIPInfo.mockResolvedValue({});
+
+    expect((await getSystemInfo({ keys: ["ip"] })).ip).toBe("203.0.113.7");
+    await getSystemInfo({ keys: ["ip"] });
+    expect(fetchIPInfo).toHaveBeenCalledTimes(2);
+  });
+
+  it("returns no blocks when aborted before starting", async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    const info = await getSystemInfo({ keys: ["user", "hostname", "cpu"], signal: controller.signal });
+
+    expect(Object.keys(info).sort()).toEqual(["platform", "timestamp"]);
+  });
+
+  it("stops at the abort and returns what was gathered", async () => {
+    const controller = new AbortController();
+    const pending = getSystemInfo({ keys: ["user", "hostname", "cpu", "kernel"], signal: controller.signal });
+    // Blocks yield to the event loop between each other; abort after the first.
+    await new Promise((resolve) => setImmediate(resolve));
+    controller.abort();
+
+    const info = await pending;
+    expect(info.user).toBeDefined();
+    expect(info.kernel).toBeUndefined();
+  });
+});

package/src/system-info-api.ts

@@ -11,9 +11,12 @@
 
 import os from "os";
 import fs from "fs";
-import https from "https";
+import { fetchIPInfo } from "./utils/network";
+import type { IPInfo } from "./utils/network";
 import path from "path";
 import type { SystemInfo, SystemInfoOptions } from "./systeminfo-types";
+import type { Cache } from "./cache/cache";
+import { isCacheValid } from "./cache/cache";
 import { CACHE_FILE } from "./info/settings"; // Using CACHE_FILE from settings to ensure consistency
 
 // Import info functions from modules
@@ -50,7 +53,7 @@ import { shell, packages, containers } from "./info/software";
  * Values are in milliseconds
  */
 const CACHE_DURATION = {
-  ip: 5 * 60 * 1000,
+  ip: 10 * 60 * 1000,
   cpu: 24 * 60 * 60 * 1000,
   gpu: 24 * 60 * 60 * 1000,
   bench: 24 * 60 * 60 * 1000,
@@ -81,41 +84,6 @@ const IS_WINDOWS = os.platform() === "win32";
 const IS_MAC = os.platform() === "darwin";
 const IS_LINUX = os.platform() === "linux";
 
-/**
- * Default IPInfo.io API token for geolocation
- */
-const DEFAULT_IPINFO_TOKEN = "da2d6cc4baa5d1";
-
-/**
- * Default network request timeout in milliseconds
- */
-const DEFAULT_NETWORK_TIMEOUT = 5000;
-
-/**
- * Represents a cached value with timestamp
- */
-interface CacheEntry {
-  value: any;
-  timestamp: number;
-}
-
-/**
- * Cache storage structure
- */
-interface Cache {
-  [key: string]: CacheEntry;
-}
-
-/**
- * IP information from ipinfo.io API
- */
-interface IPInfo {
-  ip?: string;
-  city?: string;
-  hostname?: string;
-  org?: string;
-}
-
 /**
  * Context object passed to info collection functions
  */
@@ -153,36 +121,6 @@ function saveCache(cache: Cache): void {
   }
 }
 
-/**
- * Fetches IP geolocation information from ipinfo.io API
- */
-async function fetchIPInfo(
-  token: string = DEFAULT_IPINFO_TOKEN,
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
-): Promise<IPInfo> {
-  return new Promise((resolve) => {
-    const url = `https://ipinfo.io/json${token ? `?token=${token}` : ""}`;
-
-    const req = https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch {
-          resolve({});
-        }
-      });
-    });
-
-    req.on("error", () => resolve({}));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({});
-    });
-  });
-}
-
 /**
  * System information collection functions map
  */
@@ -224,34 +162,78 @@ export const infoFunctions = {
   screen_resolution,
 };
 
+/** Blocks derived from the public IP lookup. */
+const IP_BLOCKS = new Set(["ip", "city", "domain", "isp"]);
+
+/** Lets pending I/O callbacks (keypresses, HTTP responses) run between blocks. */
+const yieldToEventLoop = () => new Promise<void>((resolve) => setImmediate(resolve));
+
 /**
- * Get all system information as a clean JSON object
+ * Returns the cached public IP lookup, or fetches it when the cache entry is
+ * older than 10 minutes. A failed fetch keeps the previous value and is still
+ * timestamped, so an offline machine is not re-queried on every launch. An
+ * aborted fetch leaves the cache untouched.
+ */
+async function getIPInfo(cache: Cache, signal?: AbortSignal): Promise<IPInfo> {
+  const entry = cache["ipInfo"];
+  if (entry && isCacheValid(entry, "ipInfo")) return entry.value || {};
+
+  const fresh = await fetchIPInfo(undefined, undefined, signal);
+  const value = fresh.ip ? fresh : entry?.value || {};
+  if (!signal?.aborted) {
+    cache["ipInfo"] = { value, timestamp: Date.now() };
+  }
+  return value;
+}
+
+/**
+ * Get system information as a clean JSON object.
+ *
+ * `options.keys` limits collection to those blocks (all by default).
+ * `options.signal` stops collection early: whatever was gathered before the
+ * abort is returned, and the remaining blocks are left out.
  */
 export async function getSystemInfo(
   options: SystemInfoOptions = {}
 ): Promise<SystemInfo> {
+  const { keys, signal } = options;
   const cache = loadCache();
   const context: InfoContext = { cache };
 
-  // Check if we need IP info
-  // Some functions need IP info, so we fetch it once if needed by any function
-  // For now we always try to fetch it if not cached, as ip/city/etc depend on it
-  // Optimization: check if we actually need to run those functions based on options if provided
-  // But current implementation fetches it always if missing from cache
+  const wanted = Object.keys(infoFunctions).filter(
+    (key) => !keys || keys.includes(key)
+  );
 
-  const cachedIPInfo = cache["ipInfo"]?.value;
-  if (cachedIPInfo) {
-    context.ipInfo = cachedIPInfo;
-  } else {
-    context.ipInfo = await fetchIPInfo();
-    // Cache IP info itself
-    cache["ipInfo"] = {
-      value: context.ipInfo,
-      timestamp: Date.now(),
-    };
+  // Start the IP lookup first so it overlaps with the local blocks.
+  const ipInfoPromise = wanted.some((key) => IP_BLOCKS.has(key))
+    ? getIPInfo(cache, signal)
+    : undefined;
+
+  const collected: Record<string, unknown> = {};
+  const run = async (key: string) => {
+    try {
+      collected[key] = await infoFunctions[key as keyof typeof infoFunctions](context);
+    } catch {
+      collected[key] = "";
+    }
+  };
+
+  for (const key of wanted) {
+    if (IP_BLOCKS.has(key)) continue;
+    await yieldToEventLoop();
+    if (signal?.aborted) break;
+    await run(key);
   }
 
-  // Collect all system information
+  // On abort the lookup resolves at once with whatever was cached.
+  if (ipInfoPromise) {
+    context.ipInfo = await ipInfoPromise;
+    for (const key of wanted) {
+      if (IP_BLOCKS.has(key)) await run(key);
+    }
+  }
+
+  // Keep the infoFunctions key order regardless of collection order.
   const info: Partial<SystemInfo> = {
     timestamp: new Date().toISOString(),
     platform: IS_WINDOWS
@@ -262,16 +244,8 @@ export async function getSystemInfo(
       ? "linux"
       : "unknown",
   };
-
-  // Call all info functions
-  for (const [key, fn] of Object.entries(infoFunctions)) {
-    try {
-      // most functions are sync but some are async (ip related)
-      const value = await fn(context);
-      info[key as keyof SystemInfo] = value as any;
-    } catch (error) {
-      info[key as keyof SystemInfo] = "" as any;
-    }
+  for (const key of wanted) {
+    if (key in collected) info[key as keyof SystemInfo] = collected[key] as any;
   }
 
   saveCache(cache);

package/src/systeminfo-types.d.ts

@@ -475,6 +475,12 @@ export interface SystemInfoOptions {
   
   /** Return data object instead of printing to console (module usage) */
   returnData?: boolean;
+
+  /** Only collect these blocks (e.g. ["cpu", "ip"]); all blocks when omitted */
+  keys?: string[];
+
+  /** Abort to stop collecting early and return only the blocks gathered so far */
+  signal?: AbortSignal;
 }
 
 /**