about-system 0.10.10 → 0.10.12

package/src/system-info-api.ts

@@ -12,8 +12,11 @@
 import os from "os";
 import fs from "fs";
 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
@@ -159,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 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(),
-    };
+  const wanted = Object.keys(infoFunctions).filter(
+    (key) => !keys || keys.includes(key)
+  );
+
+  // 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);
+  }
+
+  // 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);
+    }
   }
 
-  // Collect all system information
+  // Keep the infoFunctions key order regardless of collection order.
   const info: Partial<SystemInfo> = {
     timestamp: new Date().toISOString(),
     platform: IS_WINDOWS
@@ -197,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

@@ -125,12 +125,12 @@ export interface SystemInfo {
   /**
    * CPU benchmark score from Geekbench 6 multi-core
    * Shows performance score (in thousands) and ranking position
-   * Uses fuzzy matching to find similar CPU models from top 1000 list
+   * Uses fuzzy matching to find similar CPU models from Top 1000 list
    * Empty string if CPU not found or benchmark data unavailable
    *
    * @example
-   * - "38k #1 top 1%" (top performing CPU)
-   * - "21k #68 top 7%" (mid-range CPU)
+   * - "38k #1 Top 1%" (top performing CPU)
+   * - "21k #68 Top 7%" (mid-range CPU)
    * - "" (CPU not in benchmark database)
    */
   bench: string;
@@ -142,9 +142,9 @@ export interface SystemInfo {
    * Empty string if CPU not found or benchmark data unavailable
    *
    * @example
-   * - "Geekbench 6: 38k (Rank #1, top 1%) - ARM" (Apple M4 Ultra)
-   * - "Geekbench 6: 21k (Rank #68, top 7%) - Intel" (Intel Core i9)
-   * - "Geekbench 6: 19k (Rank #91, top 10%) - AMD" (AMD Ryzen 9 7950X)
+   * - "Geekbench 6: 38k (Rank #1, Top 1%) - ARM" (Apple M4 Ultra)
+   * - "Geekbench 6: 21k (Rank #68, Top 7%) - Intel" (Intel Core i9)
+   * - "Geekbench 6: 19k (Rank #91, Top 10%) - AMD" (AMD Ryzen 9 7950X)
    * - "" (CPU not in benchmark database)
    */
   cpu_bench_info: string;
@@ -156,8 +156,8 @@ export interface SystemInfo {
    * Empty string if GPU not found or benchmark data unavailable
    *
    * @example
-   * - "38k #1 top 1%" (top performing GPU)
-   * - "21k #68 top 7%" (mid-range GPU)
+   * - "38k #1 Top 1%" (top performing GPU)
+   * - "21k #68 Top 7%" (mid-range GPU)
    * - "" (GPU not in benchmark database)
    */
   gpu_bench: string;
@@ -169,8 +169,8 @@ export interface SystemInfo {
    * Empty string if GPU not found or benchmark data unavailable
    *
    * @example
-   * - "Geekbench 6: 38k (Rank #1, top 1%) - NVIDIA" (NVIDIA GPU)
-   * - "Geekbench 6: 21k (Rank #68, top 7%) - AMD" (AMD GPU)
+   * - "Geekbench 6: 38k (Rank #1, Top 1%) - NVIDIA" (NVIDIA GPU)
+   * - "Geekbench 6: 21k (Rank #68, Top 7%) - AMD" (AMD GPU)
    * - "" (GPU not in benchmark database)
    */
   gpu_bench_info: string;
@@ -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;
 }
 
 /**

package/src/utils/network.ts

@@ -3,6 +3,7 @@
  * @module network
  */
 
+import http from "http";
 import https from "https";
 import {
   DEFAULT_IPINFO_TOKEN,
@@ -29,6 +30,7 @@ export interface IPInfo {
  * @interface IPAPIInfo
  */
 interface IPAPIInfo {
+  status?: string;
   query?: string;
   city?: string;
   isp?: string;
@@ -37,122 +39,139 @@ interface IPAPIInfo {
 }
 
 /**
- * Fetches IP geolocation information from ipinfo.io lite API
- * @param {string} token - IPInfo.io API token
- * @param {number} timeout - Request timeout in milliseconds
- * @returns {Promise<IPInfo>} IP information object or empty object on error
+ * GETs a URL and parses the body as JSON. Never rejects: resolves `null` on
+ * any error, on abort, or once `timeout` ms have passed in total — a hard
+ * deadline for the whole request, not a socket-idle timeout.
  */
-async function fetchFromIPInfo(
-  token: string = DEFAULT_IPINFO_TOKEN,
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
-): Promise<IPInfo> {
+function getJSON(
+  url: string,
+  timeout: number,
+  signal?: AbortSignal
+): Promise<any> {
   return new Promise((resolve) => {
-    const url = `https://api.ipinfo.io/lite/8.8.8.8?token=${token}`;
+    if (signal?.aborted) return resolve(null);
 
-    const req = https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => {
-        try {
-          const parsed = JSON.parse(data);
-          // ipinfo lite returns: { ip, city, region, country, org }
-          // Map to our standard IPInfo format
-          resolve({
-            ip: parsed.ip,
-            city: parsed.city,
-            hostname: parsed.hostname,
-            org: parsed.org,
-          });
-        } catch {
-          resolve({});
-        }
-      });
-    });
+    let settled = false;
+    let req: http.ClientRequest | undefined;
+    const finish = (value: any) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve(value);
+    };
+    const onAbort = () => {
+      req?.destroy();
+      finish(null);
+    };
+    const timer = setTimeout(onAbort, timeout);
+    signal?.addEventListener("abort", onAbort);
 
-    req.on("error", () => resolve({}));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({});
-    });
+    try {
+      const get = url.startsWith("https:") ? https.get : http.get;
+      req = get(url, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            finish(JSON.parse(data));
+          } catch {
+            finish(null);
+          }
+        });
+        res.on("error", () => finish(null));
+      });
+      req.on("error", () => finish(null));
+    } catch {
+      finish(null);
+    }
   });
 }
 
 /**
- * Fetches IP geolocation information from ip-api.com (fallback)
- * @param {number} timeout - Request timeout in milliseconds
+ * Fetches IP information for this machine from the ipinfo.io lite API
+ * @param {string} token - IPInfo.io API token
+ * @param {number} timeout - Total request deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons the request when aborted
  * @returns {Promise<IPInfo>} IP information object or empty object on error
  */
-async function fetchFromIPAPI(
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
+export async function fetchFromIPInfo(
+  token: string = DEFAULT_IPINFO_TOKEN,
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
 ): Promise<IPInfo> {
-  return new Promise((resolve) => {
-    const url = "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as";
-
-    const req = https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => (data += chunk));
-      res.on("end", () => {
-        try {
-          const parsed: IPAPIInfo = JSON.parse(data);
-          if (parsed.status === "success") {
-            // Map ip-api response to our standard IPInfo format
-            resolve({
-              ip: parsed.query,
-              city: parsed.city,
-              hostname: undefined,
-              org: parsed.org || parsed.isp || parsed.as,
-            });
-          } else {
-            resolve({});
-          }
-        } catch {
-          resolve({});
-        }
-      });
-    });
+  const parsed = await getJSON(
+    `https://api.ipinfo.io/lite/me?token=${token}`,
+    timeout,
+    signal
+  );
+  if (!parsed || typeof parsed !== "object") return {};
+  // ipinfo lite returns { ip, asn, as_name, country, ... } — no city.
+  const org =
+    parsed.org ?? (parsed.asn && parsed.as_name ? `${parsed.asn} ${parsed.as_name}` : undefined);
+  return {
+    ip: parsed.ip,
+    city: parsed.city,
+    hostname: parsed.hostname,
+    org,
+  };
+}
 
-    req.on("error", () => resolve({}));
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({});
-    });
-  });
+/**
+ * Fetches IP geolocation information from ip-api.com (fallback). The free
+ * tier is plain HTTP only.
+ * @param {number} timeout - Total request deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons the request when aborted
+ * @returns {Promise<IPInfo>} IP information object or empty object on error
+ */
+export async function fetchFromIPAPI(
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
+): Promise<IPInfo> {
+  const parsed: IPAPIInfo | null = await getJSON(
+    "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as",
+    timeout,
+    signal
+  );
+  if (!parsed || parsed.status !== "success") return {};
+  return {
+    ip: parsed.query,
+    city: parsed.city,
+    hostname: undefined,
+    org: parsed.org || parsed.isp || parsed.as,
+  };
 }
 
 /**
- * Fetches IP geolocation information using race between ipinfo.io and ip-api.com
- * Uses ipinfo.io lite endpoint first, falls back to ip-api.com if slower or fails
+ * Fetches IP information from ipinfo.io and ip-api.com in parallel and merges
+ * them: ipinfo.io wins per field, ip-api.com fills the gaps (ipinfo lite has
+ * no city). Both requests share the same deadline, so this never takes longer
+ * than `timeout`.
  * @param {string} token - IPInfo.io API token
- * @param {number} timeout - Request timeout in milliseconds
+ * @param {number} timeout - Total deadline in milliseconds
+ * @param {AbortSignal} signal - Abandons both requests when aborted
  * @returns {Promise<IPInfo>} IP information object or empty object on error
  */
 export async function fetchIPInfo(
   token: string = DEFAULT_IPINFO_TOKEN,
-  timeout: number = DEFAULT_NETWORK_TIMEOUT
+  timeout: number = DEFAULT_NETWORK_TIMEOUT,
+  signal?: AbortSignal
 ): Promise<IPInfo> {
-  // Race both services, use whichever responds first
-  const [ipinfoResult, ipapiResult] = await Promise.allSettled([
-    fetchFromIPInfo(token, timeout),
-    fetchFromIPAPI(timeout),
+  const [ipinfo, ipapi] = await Promise.all([
+    fetchFromIPInfo(token, timeout, signal),
+    fetchFromIPAPI(timeout, signal),
   ]);
 
-  // Prefer ipinfo.io result if successful and has data
-  if (ipinfoResult.status === "fulfilled" && ipinfoResult.value && ipinfoResult.value.ip) {
-    return ipinfoResult.value;
+  const merged: IPInfo = {};
+  for (const source of [ipapi, ipinfo]) {
+    for (const [key, value] of Object.entries(source)) {
+      if (value) merged[key as keyof IPInfo] = value;
+    }
   }
-
-  // Fall back to ip-api.com result if successful and has data
-  if (ipapiResult.status === "fulfilled" && ipapiResult.value && ipapiResult.value.ip) {
-    return ipapiResult.value;
-  }
-
-  // Return whichever has data, or empty object
-  if (ipinfoResult.status === "fulfilled" && ipinfoResult.value) {
-    return ipinfoResult.value;
+  // ipinfo answers over IPv6 when the machine has it; the short IPv4 address
+  // reads better in a one-line greeting, so keep ip-api's when it has one.
+  if (merged.ip?.includes(":") && ipapi.ip && !ipapi.ip.includes(":")) {
+    merged.ip = ipapi.ip;
   }
-  if (ipapiResult.status === "fulfilled" && ipapiResult.value) {
-    return ipapiResult.value;
-  }
-
-  return {};
-}
+  return merged;
+}