about-system 0.0.18 → 0.0.21

package/src/system-info-api.ts

@@ -7,53 +7,46 @@
  * @module system-info-api
  * @author vtempest
  * @license rights.institute/prosper
- *
- * @example
- * ```typescript
- * import { getSystemInfo } from 'about-system';
- *
- * const info = await getSystemInfo();
- * console.log(info.cpu);        // "AMD Ryzen 9 5900HX"
- * console.log(info.ram_used);   // "8/16GB"
- * console.log(info.platform);   // "linux"
- * ```
  */
 
 import os from "os";
 import fs from "fs";
-import path from "path";
-import { execSync } from "child_process";
 import https from "https";
-import type { SystemInfo, SystemInfoOptions } from "./systeminfo-types.js";
-
-/**
- * Cache file location in system's temporary directory
- * @constant
- */
-const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
+import path from "path";
+import type { SystemInfo, SystemInfoOptions } from "./systeminfo-types";
+import { CACHE_FILE } from "./info/settings"; // Using CACHE_FILE from settings to ensure consistency
+
+// Import info functions from modules
+import { user, hostname, os_info, kernel, device } from "./info/platform";
+import { cpu, gpu, screen_resolution } from "./info/hardware";
+import {
+  disk_used,
+  ram_used,
+  memory_available,
+  swap_used,
+  mount_points,
+} from "./info/memory";
+import { top_process, uptime, users_logged_in } from "./info/process";
+import {
+  ip,
+  iplocal,
+  city,
+  domain,
+  isp,
+  network_interfaces,
+  ports,
+} from "./info/network";
+import {
+  services_running,
+  temperature,
+  battery,
+  load_average,
+} from "./info/system-status";
+import { shell, packages, containers } from "./info/software";
 
 /**
  * Cache duration configuration for different system information types
  * Values are in milliseconds
- *
- * @constant
- * @property {number} ip - IP information cache (5 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)
- * @property {number} device - Device information cache (24 hours)
- * @property {number} kernel - Kernel information cache (1 hour)
- * @property {number} pacman - Package managers cache (10 minutes)
- * @property {number} ports - Open ports cache (5 minutes)
- * @property {number} containers - Docker containers cache (5 minutes)
- * @property {number} top_process - Top process cache (5 seconds)
- * @property {number} disk_used - Disk usage cache (1 minute)
- * @property {number} ram_used - RAM usage cache (10 seconds)
- * @property {number} services_running - Services cache (5 minutes)
- * @property {number} temperature - Temperature cache (30 seconds)
- * @property {number} battery - Battery status cache (1 minute)
- * @property {number} network_interfaces - Network interfaces cache (5 minutes)
- * @property {number} mount_points - Mount points cache (10 minutes)
  */
 const CACHE_DURATION = {
   ip: 5 * 60 * 1000,
@@ -84,30 +77,24 @@ const IS_LINUX = os.platform() === "linux";
 
 /**
  * Default IPInfo.io API token for geolocation
- * @constant
  */
 const DEFAULT_IPINFO_TOKEN = "da2d6cc4baa5d1";
 
 /**
  * Default network request timeout in milliseconds
- * @constant
  */
 const DEFAULT_NETWORK_TIMEOUT = 5000;
 
 /**
  * Represents a cached value with timestamp
- * @interface CacheEntry
  */
 interface CacheEntry {
-  /** The cached value */
   value: any;
-  /** Unix timestamp when the value was cached */
   timestamp: number;
 }
 
 /**
  * Cache storage structure
- * @interface Cache
  */
 interface Cache {
   [key: string]: CacheEntry;
@@ -115,33 +102,24 @@ interface Cache {
 
 /**
  * IP information from ipinfo.io API
- * @interface IPInfo
  */
 interface IPInfo {
-  /** Public IP address */
   ip?: string;
-  /** City location */
   city?: string;
-  /** Reverse DNS hostname */
   hostname?: string;
-  /** ISP organization string (includes AS number) */
   org?: string;
 }
 
 /**
  * Context object passed to info collection functions
- * @interface InfoContext
  */
 interface InfoContext {
-  /** Cache storage */
   cache: Cache;
-  /** IP information from external API */
   ipInfo?: IPInfo;
 }
 
 /**
  * Loads cache from disk
- * @returns {Cache} Cached data or empty object if cache doesn't exist or is corrupted
  */
 function loadCache(): Cache {
   try {
@@ -156,103 +134,21 @@ function loadCache(): Cache {
 
 /**
  * Saves cache to disk
- * @param {Cache} cache - Cache object to save
  */
 function saveCache(cache: Cache): void {
   try {
+    const cacheDir = path.dirname(CACHE_FILE);
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
+    }
     fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
   } catch (error) {
     // Silently fail if can't write cache
   }
 }
 
-/**
- * Checks if a cache entry is still valid based on configured duration
- * @param {CacheEntry} cacheEntry - The cache entry to validate
- * @param {string} key - The key name to determine cache duration
- * @returns {boolean} True if cache is still valid
- */
-function isCacheValid(cacheEntry: CacheEntry, key: string): boolean {
-  if (!cacheEntry || !cacheEntry.timestamp) return false;
-  const age = Date.now() - cacheEntry.timestamp;
-  const maxAge = CACHE_DURATION[key as keyof typeof CACHE_DURATION] || 60000;
-  return age < maxAge;
-}
-
-/**
- * Retrieves a value from cache if valid
- * @param {Cache} cache - Cache object
- * @param {string} key - Key to retrieve
- * @returns {any} Cached value or null if not found/expired
- */
-function getCachedValue(cache: Cache, key: string): any {
-  if (!cache[key]) return null;
-  const cacheEntry = cache[key];
-  if (!isCacheValid(cacheEntry, key)) {
-    delete cache[key];
-    return null;
-  }
-  return cacheEntry.value;
-}
-
-/**
- * Stores a value in cache with current timestamp
- * @param {Cache} cache - Cache object
- * @param {string} key - Key to store under
- * @param {any} value - Value to cache
- */
-function setCachedValue(cache: Cache, key: string, value: any): void {
-  cache[key] = {
-    value,
-    timestamp: Date.now(),
-  };
-}
-
-/**
- * Executes a shell command safely with timeout
- * @param {string} command - Command to execute
- * @param {object} options - Additional options for execSync
- * @returns {string} Command output or empty string on error
- */
-function execCommand(command: string, options = {}): string {
-  try {
-    const cmd = IS_WINDOWS ? `cmd /c ${command}` : command;
-    return execSync(cmd, {
-      encoding: "utf8",
-      timeout: 10000,
-      stdio: ["pipe", "pipe", "ignore"],
-      ...options,
-    })
-      .toString()
-      .trim();
-  } catch (error) {
-    return "";
-  }
-}
-
-/**
- * Checks if a command exists in the system PATH
- * @param {string} command - Command name to check
- * @returns {boolean} True if command exists
- */
-function commandExists(command: string): boolean {
-  try {
-    if (IS_WINDOWS) {
-      execSync(`where ${command}`, { stdio: "ignore" });
-    } else {
-      execSync(`which ${command}`, { stdio: "ignore" });
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Fetches IP geolocation information from ipinfo.io 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
  */
 async function fetchIPInfo(
   token: string = DEFAULT_IPINFO_TOKEN,
@@ -282,988 +178,43 @@ async function fetchIPInfo(
 }
 
 /**
- * System information collection functions
- * Each function returns a clean string value without formatting
- * @namespace infoFunctions
+ * System information collection functions map
  */
 export const infoFunctions = {
-  /**
-   * Gets the current username
-   * @returns Current system username
-   */
-  user(): string {
-    return os.userInfo().username;
-  },
-
-  /**
-   * Gets the system hostname
-   * @returns Computer hostname/network name
-   */
-  hostname(): string {
-    return os.hostname();
-  },
-
-  /**
-   * Gets public IP address from ipinfo.io
-   * @param context - Info context with cache and IP info
-   * @returns Public IPv4 address or empty string
-   * @example "203.0.113.42"
-   */
-  async 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;
-  },
-
-  /**
-   * Gets local/private IP address(es)
-   * Tries ifconfig and ip commands on Linux, falls back to Node.js API
-   * @returns Space-separated local IP addresses (RFC 1918 ranges)
-   * @example "192.168.1.100" or "10.0.0.50 192.168.1.100"
-   */
-  iplocal(): string {
-    if (IS_LINUX) {
-      try {
-        const ifconfig = execCommand("ifconfig 2>/dev/null");
-        const wlanMatch = ifconfig.match(
-          /wlan0[\s\S]*?inet (\d+\.\d+\.\d+\.\d+)/
-        );
-        if (wlanMatch) {
-          return wlanMatch[1];
-        }
-      } catch {}
-
-      try {
-        const ipAddr = execCommand("ip addr show 2>/dev/null");
-        const addresses: string[] = [];
-        const matches = ipAddr.matchAll(/inet (\d+\.\d+\.\d+\.\d+)\/\d+/g);
-        for (const match of matches) {
-          if (!match[1].startsWith("127.")) {
-            addresses.push(match[1]);
-          }
-        }
-        if (addresses.length > 0) {
-          return addresses.join(" ");
-        }
-      } catch {}
-    }
-
-    const interfaces = os.networkInterfaces();
-    const addresses: string[] = [];
-
-    for (const name of Object.keys(interfaces)) {
-      for (const device of interfaces[name] || []) {
-        if (device.family === "IPv4" && !device.internal) {
-          addresses.push(device.address);
-        }
-      }
-    }
-
-    return addresses.join(" ");
-  },
-
-  /**
-   * 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"
-   */
-  async 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;
-  },
-
-  /**
-   * Gets reverse DNS hostname with HTTP prefix
-   * @param context - Info context with IP info
-   * @returns Domain with http:// prefix or empty string
-   * @example "http://example.com", "http://host-203-0-113-42.example.net"
-   */
-  async 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;
-  },
-
-  /**
-   * Gets Internet Service Provider name
-   * Strips AS number prefix from organization string
-   * @param context - Info context with IP info
-   * @returns ISP name or empty string
-   * @example "Comcast Cable", "Verizon Business", "Cloudflare Inc"
-   */
-  async 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;
-  },
-
-  /**
-   * Gets operating system name and version
-   * Platform-specific detection for Windows, macOS, and Linux
-   * @param context - Info context with cache
-   * @returns OS name and version string
-   * @example "Windows 11 Pro", "macOS Ventura 13.2.1", "Ubuntu 22.04.3 LTS"
-   */
-  os(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "os");
-    if (cached) return cached;
-
-    const platform = os.platform();
-    const release = os.release();
-    let osName = "";
-
-    if (IS_WINDOWS) {
-      try {
-        const version = execCommand("ver");
-        const match = version.match(/Microsoft Windows \[Version ([^\]]+)\]/);
-        osName = match ? `Windows ${match[1]}` : `Windows ${release}`;
-      } catch {
-        osName = `Windows ${release}`;
-      }
-    } else if (IS_MAC) {
-      osName = `macOS ${release}`;
-    } else if (IS_LINUX) {
-      try {
-        const osRelease = fs.readFileSync("/etc/os-release", "utf8");
-        const nameMatch = osRelease.match(/^NAME="([^"]+)"/m);
-        const versionMatch = osRelease.match(/^VERSION_ID="([^"]+)"/m);
-        osName = nameMatch ? nameMatch[1] : "Linux";
-        if (versionMatch) osName += ` ${versionMatch[1]}`;
-      } catch {
-        osName = `Linux ${release}`;
-      }
-    } else {
-      osName = `${platform} ${release}`;
-    }
-
-    setCachedValue(context.cache, "os", osName);
-    return osName;
-  },
-
-  /**
-   * Gets CPU model name and specifications
-   * Uses platform-specific commands (wmic/lscpu/cpuinfo)
-   * Automatically strips "with Radeon Graphics" and similar suffixes
-   * @param context - Info context with cache
-   * @returns CPU model string or empty string
-   * @example "Intel Core i7-12700K", "AMD Ryzen 9 5900HX", "Apple M2 Pro"
-   */
-  cpu(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "cpu");
-    if (cached) return cached;
-
-    let cpuName = "";
-
-    if (IS_WINDOWS) {
-      try {
-        const wmic = execCommand("wmic cpu get name /format:list");
-        const nameMatch = wmic.match(/Name=(.+)/);
-        if (nameMatch) {
-          cpuName = nameMatch[1].trim();
-        }
-      } catch {}
-
-      if (!cpuName) {
-        try {
-          const ps = execCommand(
-            'powershell.exe -Command "Get-WmiObject -Class Win32_Processor | Select-Object -ExpandProperty Name"'
-          );
-          if (ps.trim()) {
-            cpuName = ps.trim();
-          }
-        } catch {}
-      }
-    } else if (IS_LINUX) {
-      try {
-        const lscpu = execCommand("lscpu");
-        const modelMatch = lscpu.match(/Model name:\s*([^\n,]+)/);
-        if (modelMatch) {
-          cpuName = modelMatch[1].trim();
-        }
-      } catch {}
-
-      if (!cpuName) {
-        try {
-          const cpuInfo = fs.readFileSync("/proc/cpuinfo", "utf8");
-          const modelMatch = cpuInfo.match(/model name\s*:\s*([^\n]+)/);
-          const hardwareMatch = cpuInfo.match(/Hardware\s*:\s*([^\n]+)/);
-
-          if (modelMatch) {
-            cpuName = modelMatch[1].trim();
-          } else if (hardwareMatch) {
-            cpuName = hardwareMatch[1].trim();
-          }
-        } catch {}
-      }
-    } else {
-      const cpus = os.cpus();
-      if (cpus.length > 0) {
-        cpuName = cpus[0].model.trim().replace(/[\r\n]+/g, " ");
-      }
-    }
-
-    if (!cpuName) {
-      setCachedValue(context.cache, "cpu", "");
-      return "";
-    }
-
-    cpuName = cpuName.trim().replace(/with .*/, "");
-
-    setCachedValue(context.cache, "cpu", cpuName);
-    return cpuName;
-  },
-
-  /**
-   * Gets graphics card model name
-   * Extracts GPU info from lspci (Linux) or WMI (Windows)
-   * Filters out basic/generic display adapters
-   * @param context - Info context with cache
-   * @returns GPU model string or empty string
-   * @example "NVIDIA GeForce RTX 4070", "AMD Radeon RX 6800 XT"
-   */
-  gpu(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "gpu");
-    if (cached !== null) return cached;
-
-    if (IS_WINDOWS) {
-      try {
-        const wmic = execCommand(
-          "wmic path win32_VideoController get name /format:list"
-        );
-        const nameMatch = wmic.match(/Name=(.+)/);
-        if (nameMatch) {
-          const gpu = nameMatch[1].trim();
-          if (gpu && gpu !== "" && !gpu.includes("Microsoft Basic")) {
-            setCachedValue(context.cache, "gpu", gpu);
-            return gpu;
-          }
-        }
-      } catch {}
-
-      try {
-        const ps = execCommand(
-          "powershell.exe -Command \"Get-WmiObject -Class Win32_VideoController | Where-Object {$_.Name -notlike '*Microsoft Basic*'} | Select-Object -First 1 -ExpandProperty Name\""
-        );
-        if (ps.trim()) {
-          const gpu = ps.trim();
-          setCachedValue(context.cache, "gpu", gpu);
-          return gpu;
-        }
-      } catch {}
-    } else if (IS_LINUX) {
-      try {
-        const lspci = execCommand("lspci");
-        const gpuMatch = lspci.match(
-          /VGA.*?(RTX|GeForce|AMD|Intel|NVIDIA)[^\n]*/i
-        );
-        if (gpuMatch) {
-          let gpu = gpuMatch[0];
-
-          const bracketMatch = gpu.match(/\[([^\]]+)\]/);
-          if (bracketMatch) {
-            gpu = bracketMatch[1];
-          } else {
-            gpu = gpu
-              .replace(/^.*VGA[^:]*:\s*/, "")
-              .replace(/\s*\(.*\)$/, "")
-              .trim();
-          }
-
-          if (gpu) {
-            setCachedValue(context.cache, "gpu", gpu);
-            return gpu;
-          }
-        }
-      } catch {}
-    }
-
-    setCachedValue(context.cache, "gpu", "");
-    return "";
-  },
-
-  /**
-   * Gets root filesystem disk usage percentage
-   * Uses df command on Linux/Android
-   * @param context - Info context with cache
-   * @returns Percentage string or empty string
-   * @example "45%", "78%"
-   */
-  disk_used(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "disk_used");
-    if (cached !== null) return cached;
-
-    if (IS_LINUX) {
-      try {
-        const df = execCommand("df -h");
-        let diskUsage = "";
-
-        if (df.includes("/storage/emulated")) {
-          const match = df.match(/\s+(\d+%)\s+\/storage\/emulated/);
-          diskUsage = match ? match[1] : "";
-        } else {
-          const lines = df.split("\n");
-          for (const line of lines) {
-            if (line.trim().endsWith(" /")) {
-              const parts = line.trim().split(/\s+/);
-              const percentIndex = parts.findIndex((part) =>
-                part.includes("%")
-              );
-              if (percentIndex !== -1) {
-                diskUsage = parts[percentIndex];
-                break;
-              }
-            }
-          }
-
-          if (!diskUsage) {
-            const rootMatch = df.match(/(\d+%)\s+\/\s*$/m);
-            diskUsage = rootMatch ? rootMatch[1] : "";
-          }
-        }
-
-        setCachedValue(context.cache, "disk_used", diskUsage);
-        return diskUsage;
-      } catch {}
-    }
-
-    setCachedValue(context.cache, "disk_used", "");
-    return "";
-  },
-
-  /**
-   * Gets memory usage in gigabytes
-   * Reads from /proc/meminfo on Linux, falls back to os.totalmem()
-   * @param context - Info context with cache
-   * @returns Memory usage as "used/total GB"
-   * @example "12/32GB", "6/16GB"
-   */
-  ram_used(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "ram_used");
-    if (cached) return cached;
-
-    if (IS_LINUX) {
-      try {
-        const meminfo = fs.readFileSync("/proc/meminfo", "utf8");
-        const totalMatch = meminfo.match(/MemTotal:\s+(\d+) kB/);
-        const freeMatch = meminfo.match(/MemFree:\s+(\d+) kB/);
-
-        if (totalMatch && freeMatch) {
-          const totalMB = Math.round(parseInt(totalMatch[1]) / 1024);
-          const freeMB = Math.round(parseInt(freeMatch[1]) / 1024);
-          const usedMB = totalMB - freeMB;
-
-          const totalGB = Math.round(totalMB / 1024);
-          const usedGB = Math.round(usedMB / 1024);
-
-          const result = `${usedGB}/${totalGB}GB`;
-          setCachedValue(context.cache, "ram_used", result);
-          return result;
-        }
-      } catch {}
-    }
-
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const usedMem = totalMem - freeMem;
-
-    const totalGB = Math.round(totalMem / (1024 * 1024 * 1024));
-    const usedGB = Math.round(usedMem / (1024 * 1024 * 1024));
-
-    const result = `${usedGB}/${totalGB}GB`;
-    setCachedValue(context.cache, "ram_used", result);
-    return result;
-  },
-
-  /**
-   * Gets the highest CPU-consuming process
-   * Uses ps command to find top process by CPU usage (Linux only)
-   * @param context - Info context with cache
-   * @returns Process info as "percentage processname" or empty string
-   * @example "8% firefox", "15% chrome", "3% systemd"
-   */
-  top_process(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "top_process");
-    if (cached !== null) return cached;
-
-    if (IS_LINUX) {
-      try {
-        const ps = execCommand("ps -eo pcpu,comm --sort=-%cpu --no-headers");
-        const lines = ps.split("\n");
-        if (lines.length > 0) {
-          const topProcess = lines[0].trim().replace(/\s+/, " ").split(" ");
-          const cpu = topProcess[0].replace(/\.\d+/, "%");
-          const process = topProcess[1].split("/").pop();
-          const result = `${cpu} ${process}`;
-          setCachedValue(context.cache, "top_process", result);
-          return result;
-        }
-      } catch {}
-    }
-
-    setCachedValue(context.cache, "top_process", "");
-    return "";
-  },
-
-  /**
-   * Gets system uptime since last boot
-   * @returns Uptime formatted as "Xd Yh Zm"
-   * @example "2d 14h 23m", "0d 3h 45m"
-   */
-  uptime(): string {
-    const uptimeSeconds = os.uptime();
-    const days = Math.floor(uptimeSeconds / 86400);
-    const hours = Math.floor((uptimeSeconds % 86400) / 3600);
-    const minutes = Math.floor((uptimeSeconds % 3600) / 60);
-    return `${days}d ${hours}h ${minutes}m`;
-  },
-
-  /**
-   * Gets device or computer model name
-   * Uses WMI on Windows, DMI on Linux, getprop on Android
-   * @param context - Info context with cache
-   * @returns Device model name or empty string
-   * @example "Dell OptiPlex 7090", "MacBook Pro 16-inch", "Valve Steam Deck"
-   */
-  device(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "device");
-    if (cached !== null) return cached;
-
-    if (IS_WINDOWS) {
-      try {
-        const wmic = execCommand("wmic csproduct get name /format:list");
-        const nameMatch = wmic.match(/Name=(.+)/);
-        if (nameMatch) {
-          const device = nameMatch[1].trim();
-          if (device && device !== "") {
-            setCachedValue(context.cache, "device", device);
-            return device;
-          }
-        }
-      } catch {}
-
-      try {
-        const ps = execCommand(
-          'powershell.exe -Command "Get-WmiObject -Class Win32_ComputerSystem | Select-Object -ExpandProperty Model"'
-        );
-        if (ps.trim()) {
-          const device = ps.trim();
-          setCachedValue(context.cache, "device", device);
-          return device;
-        }
-      } catch {}
-    } else if (IS_LINUX) {
-      try {
-        if (commandExists("getprop")) {
-          const device = execCommand("getprop ro.product.model");
-          if (device) {
-            setCachedValue(context.cache, "device", device);
-            return device;
-          }
-        }
-
-        const dmiPath = "/sys/devices/virtual/dmi/id/product_name";
-        if (fs.existsSync(dmiPath)) {
-          const device = fs.readFileSync(dmiPath, "utf8").trim();
-          if (device) {
-            setCachedValue(context.cache, "device", device);
-            return device;
-          }
-        }
-      } catch {}
-    }
-
-    setCachedValue(context.cache, "device", "");
-    return "";
-  },
-
-  /**
-   * Gets kernel version string
-   * Returns the operating system kernel version from os.release()
-   * @param context - Info context with cache
-   * @returns Kernel version string
-   * @example "5.15.0-56-generic", "6.11.11-valve12-1-neptune"
-   */
-  kernel(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "kernel");
-    if (cached) return cached;
-
-    const kernel = os.release();
-    setCachedValue(context.cache, "kernel", kernel);
-    return kernel;
-  },
-
-  /**
-   * Gets the current shell name
-   * Uses ps command to find parent process shell (Linux/Unix only)
-   * @returns Shell name or empty string on Windows
-   * @example "bash", "zsh", "fish", "nu"
-   */
-  shell(): string {
-    if (IS_LINUX) {
-      try {
-        const ppid = process.ppid;
-        const shell = execCommand(`ps -p ${ppid} -o comm=`).split("/").pop();
-        return shell || "";
-      } catch {}
-    }
-    return "";
-  },
-
-  /**
-   * Gets available package managers and development tools
-   * Checks for package managers (apt, yum, npm, etc.) and editors (nvim, hx)
-   * @param context - Info context with cache
-   * @returns Space-separated list of available commands
-   * @example "apt npm docker nvim", "yay pacman bun hx"
-   */
-  pacman(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "pacman");
-    if (cached !== null) return cached;
-
-    const commands = [
-      "apt",
-      "npm",
-      "uv",
-      "docker",
-      "hx",
-      "nvim",
-      "bun",
-      "yay",
-      "pacman",
-      "yum",
-      "dnf",
-      "zypper",
-      "emerge",
-      "apk",
-      "snap",
-      "flatpak",
-    ];
-    const available = commands.filter((cmd) => commandExists(cmd));
-
-    const result = available.join(" ");
-    setCachedValue(context.cache, "pacman", result);
-    return result;
-  },
-
-  /**
-   * Gets open TCP ports with service names
-   * Uses lsof to find listening TCP ports (Linux only)
-   * @param context - Info context with cache
-   * @returns Space-separated port+process pairs or empty string
-   * @example "80http 443http 22ssh", "3000node 5432post"
-   */
-  ports(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "ports");
-    if (cached !== null) return cached;
-
-    if (IS_LINUX) {
-      try {
-        const lsof = execCommand("lsof -nP -iTCP -sTCP:LISTEN");
-        const lines = lsof.split("\n").slice(1);
-        const ports = new Set<string>();
-
-        lines.forEach((line) => {
-          const parts = line.split(/\s+/);
-          if (parts.length >= 9) {
-            const address = parts[8];
-            const portMatch = address.match(/:(\d+)$/);
-            if (portMatch) {
-              const port = portMatch[1];
-              const process = parts[0].substring(0, 4);
-              ports.add(`${port}${process}`);
-            }
-          }
-        });
-
-        const result = Array.from(ports).join(" ");
-        setCachedValue(context.cache, "ports", result);
-        return result;
-      } catch {}
-    }
-
-    setCachedValue(context.cache, "ports", "");
-    return "";
-  },
-
-  /**
-   * Gets running Docker container names
-   * Lists active Docker containers with their names
-   * @param context - Info context with cache
-   * @returns Space-separated container names or empty string
-   * @example "nginx redis postgres", "web-app db-server"
-   */
-  containers(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "containers");
-    if (cached !== null) return cached;
-
-    if (!commandExists("docker")) {
-      setCachedValue(context.cache, "containers", "");
-      return "";
-    }
-
-    try {
-      const containerCount = execCommand("docker ps -q")
-        .split("\n")
-        .filter((line) => line.trim()).length;
-      if (containerCount === 0) {
-        setCachedValue(context.cache, "containers", "");
-        return "";
-      }
-
-      const containers = execCommand(
-        'docker ps --format "{{.Names}}\t{{.Ports}}"'
-      );
-      const lines = containers.split("\n").filter((line) => line.trim());
-
-      const containerInfo: string[] = [];
-
-      lines.forEach((line) => {
-        const [name, ports] = line.split("\t");
-        if (name) {
-          containerInfo.push(name);
-
-          if (ports) {
-            const portMatches = ports.match(/->(\d+(-\d+)?)\//g);
-            if (portMatches) {
-              const uniquePorts = [
-                ...new Set(
-                  portMatches.map((p) => p.replace(/->\d+(-\d+)?\//, ""))
-                ),
-              ];
-              containerInfo.push(...uniquePorts);
-            }
-          }
-        }
-      });
-
-      const result = containerInfo.join(" ");
-      setCachedValue(context.cache, "containers", result);
-      return result;
-    } catch {}
-
-    setCachedValue(context.cache, "containers", "");
-    return "";
-  },
-
-  /**
-   * Gets available memory in gigabytes
-   * Reads MemAvailable from /proc/meminfo (Linux only)
-   * @returns Available memory with "GB available" suffix or empty string
-   * @example "12GB available", "4GB available"
-   */
-  memory_available(): string {
-    if (!IS_LINUX) return "";
-
-    try {
-      const meminfo = fs.readFileSync("/proc/meminfo", "utf8");
-      const availableMatch = meminfo.match(/MemAvailable:\s+(\d+) kB/);
-      if (availableMatch) {
-        const availableGB = Math.round(
-          parseInt(availableMatch[1]) / 1024 / 1024
-        );
-        return `${availableGB}GB available`;
-      }
-    } catch {}
-    return "";
-  },
-
-  /**
-   * Gets swap memory usage
-   * Calculates swap usage from /proc/meminfo (Linux only)
-   * @returns Swap usage as "percentage (size MB) swap" or empty string
-   * @example "15% (512MB) swap", "0% (0MB) swap"
-   */
-  swap_used(): string {
-    if (!IS_LINUX) return "";
-
-    try {
-      const meminfo = fs.readFileSync("/proc/meminfo", "utf8");
-      const swapTotalMatch = meminfo.match(/SwapTotal:\s+(\d+) kB/);
-      const swapFreeMatch = meminfo.match(/SwapFree:\s+(\d+) kB/);
-
-      if (swapTotalMatch && swapFreeMatch) {
-        const swapTotal = parseInt(swapTotalMatch[1]);
-        const swapFree = parseInt(swapFreeMatch[1]);
-        const swapUsed = swapTotal - swapFree;
-
-        if (swapTotal > 0) {
-          const swapUsedPercent = Math.round((swapUsed / swapTotal) * 100);
-          const swapUsedMB = Math.round(swapUsed / 1024);
-          return `${swapUsedPercent}% (${swapUsedMB}MB) swap`;
-        }
-      }
-    } catch {}
-    return "";
-  },
-
-  /**
-   * Gets system load averages
-   * Reads 1, 5, and 15 minute load averages from /proc/loadavg (Linux only)
-   * @returns Space-separated load averages (1m 5m 15m) or empty string
-   * @example "0.52 0.58 0.59", "2.10 1.95 1.88"
-   */
-  load_average(): string {
-    if (!IS_LINUX) return "";
-
-    try {
-      const loadavg = fs.readFileSync("/proc/loadavg", "utf8");
-      const loads = loadavg.split(" ").slice(0, 3);
-      return loads.join(" ");
-    } catch {}
-    return "";
-  },
-
-  /**
-   * Gets number of logged in users
-   * Uses who command to count active user sessions (Linux only)
-   * @returns User count with "users" suffix or empty string
-   * @example "3 users", "1 users"
-   */
-  users_logged_in(): string {
-    if (!IS_LINUX) return "";
-
-    try {
-      const who = execCommand("who");
-      const users = who.split("\n").filter((line) => line.trim()).length;
-      if (users > 0) {
-        return `${users} users`;
-      }
-    } catch {}
-    return "";
-  },
-
-  /**
-   * Gets active network interface names
-   * Lists non-loopback interfaces with IPv4 addresses (Linux only)
-   * @param context - Info context with cache
-   * @returns Space-separated interface names or empty string
-   * @example "eth0 wlan0", "enp0s3"
-   */
-  network_interfaces(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "network_interfaces");
-    if (cached !== null) return cached;
-
-    if (!IS_LINUX) {
-      setCachedValue(context.cache, "network_interfaces", "");
-      return "";
-    }
-
-    try {
-      const interfaces = os.networkInterfaces();
-      const activeInterfaces: string[] = [];
-
-      for (const [name, addrs] of Object.entries(interfaces)) {
-        if (name !== "lo") {
-          const ipv4Addr = addrs?.find(
-            (addr) => addr.family === "IPv4" && !addr.internal
-          );
-          if (ipv4Addr) {
-            activeInterfaces.push(name);
-          }
-        }
-      }
-
-      const result = activeInterfaces.join(" ");
-      setCachedValue(context.cache, "network_interfaces", result);
-      return result;
-    } catch {}
-
-    setCachedValue(context.cache, "network_interfaces", "");
-    return "";
-  },
-
-  mount_points(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "mount_points");
-    if (cached !== null) return cached;
-
-    if (!IS_LINUX) {
-      setCachedValue(context.cache, "mount_points", "");
-      return "";
-    }
-
-    try {
-      const df = execCommand("df -h");
-      const lines = df.split("\n").slice(1);
-      const mountPoints: string[] = [];
-
-      lines.forEach((line) => {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length >= 6) {
-          const mountPoint = parts[5];
-          const usage = parts[4];
-          if (
-            !mountPoint.startsWith("/dev") &&
-            !mountPoint.startsWith("/proc") &&
-            !mountPoint.startsWith("/sys") &&
-            mountPoint !== "/"
-          ) {
-            mountPoints.push(`${mountPoint}(${usage})`);
-          }
-        }
-      });
-
-      const result = mountPoints.slice(0, 3).join(" ");
-      setCachedValue(context.cache, "mount_points", result);
-      return result;
-    } catch {}
-
-    setCachedValue(context.cache, "mount_points", "");
-    return "";
-  },
-
-  services_running(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "services_running");
-    if (cached !== null) return cached;
-
-    if (!IS_LINUX) {
-      setCachedValue(context.cache, "services_running", "");
-      return "";
-    }
-
-    try {
-      let serviceCount = 0;
-
-      if (commandExists("systemctl")) {
-        const services = execCommand(
-          "systemctl list-units --type=service --state=running --no-pager"
-        );
-        serviceCount = services
-          .split("\n")
-          .filter((line) => line.includes(".service")).length;
-      } else if (commandExists("service")) {
-        const services = execCommand("service --status-all");
-        serviceCount = services
-          .split("\n")
-          .filter((line) => line.includes("+")).length;
-      }
-
-      if (serviceCount > 0) {
-        const result = `${serviceCount} services`;
-        setCachedValue(context.cache, "services_running", result);
-        return result;
-      }
-    } catch {}
-
-    setCachedValue(context.cache, "services_running", "");
-    return "";
-  },
-
-  temperature(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "temperature");
-    if (cached !== null) return cached;
-
-    if (!IS_LINUX) {
-      setCachedValue(context.cache, "temperature", "");
-      return "";
-    }
-
-    try {
-      const tempSources = [
-        "/sys/class/thermal/thermal_zone0/temp",
-        "/sys/class/hwmon/hwmon0/temp1_input",
-        "/sys/class/hwmon/hwmon1/temp1_input",
-      ];
-
-      for (const source of tempSources) {
-        if (fs.existsSync(source)) {
-          const temp = fs.readFileSync(source, "utf8").trim();
-          const tempC = Math.round(parseInt(temp) / 1000);
-
-          if (tempC > 0 && tempC < 150) {
-            const result = `${tempC}°C`;
-            setCachedValue(context.cache, "temperature", result);
-            return result;
-          }
-        }
-      }
-    } catch {}
-
-    setCachedValue(context.cache, "temperature", "");
-    return "";
-  },
-
-  battery(context: InfoContext): string {
-    const cached = getCachedValue(context.cache, "battery");
-    if (cached !== null) return cached;
-
-    if (!IS_LINUX) {
-      setCachedValue(context.cache, "battery", "");
-      return "";
-    }
-
-    try {
-      const batteryPath = "/sys/class/power_supply/BAT0";
-      const capacityPath = `${batteryPath}/capacity`;
-      const statusPath = `${batteryPath}/status`;
-
-      if (fs.existsSync(capacityPath)) {
-        const capacity = fs.readFileSync(capacityPath, "utf8").trim();
-        const status = fs.existsSync(statusPath)
-          ? fs.readFileSync(statusPath, "utf8").trim()
-          : "Unknown";
-
-        const batteryPercent = parseInt(capacity);
-        const isCharging = status === "Charging";
-        const result = `${batteryPercent}%${isCharging ? "+" : ""}`;
-        setCachedValue(context.cache, "battery", result);
-        return result;
-      }
-    } catch {}
-
-    setCachedValue(context.cache, "battery", "");
-    return "";
-  },
-
-  screen_resolution(): string {
-    if (!IS_LINUX) return "";
-
-    try {
-      if (process.env.DISPLAY) {
-        const xrandr = execCommand("xrandr");
-        const resolutionMatch = xrandr.match(/(\d+x\d+)\+\d+\+\d+/);
-        if (resolutionMatch) {
-          return resolutionMatch[1];
-        }
-      }
-    } catch {}
-    return "";
-  },
+  user,
+  hostname,
+  ip,
+  iplocal,
+  city,
+  domain,
+  isp,
+  os: os_info, // Mapped from os_info
+  cpu,
+  gpu,
+  disk_used,
+  ram_used,
+  top_process,
+  uptime,
+  device,
+  kernel,
+  shell,
+  pacman: packages, // Mapped from packages
+  ports,
+  containers,
+  memory_available,
+  swap_used,
+  load_average,
+  users_logged_in,
+  network_interfaces,
+  mount_points,
+  services_running,
+  temperature,
+  battery,
+  screen_resolution,
 };
 
 /**
  * Get all system information as a clean JSON object
- * @param options Configuration options
- * @returns Promise resolving to SystemInfo object
  */
 export async function getSystemInfo(
   options: SystemInfoOptions = {}
@@ -1272,12 +223,21 @@ export async function getSystemInfo(
   const context: InfoContext = { cache };
 
   // Check if we need IP info
-  const cachedIPInfo = getCachedValue(cache, "ipInfo");
+  // 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();
-    setCachedValue(cache, "ipInfo", context.ipInfo);
+    // Cache IP info itself
+    cache["ipInfo"] = {
+      value: context.ipInfo,
+      timestamp: Date.now(),
+    };
   }
 
   // Collect all system information
@@ -1295,6 +255,7 @@ export async function getSystemInfo(
   // 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) {