about-system 0.0.18 → 0.0.21

package/src/cache/cache.ts

@@ -0,0 +1,95 @@
+/**
+ * Cache management utilities
+ * @module cache
+ */
+
+import fs from "fs";
+import { CACHE_FILE, CACHE_DURATION } from "./cache-config";
+
+/**
+ * Represents a cached value with timestamp
+ * @interface CacheEntry
+ */
+export interface CacheEntry {
+  /** The cached value */
+  value: any;
+  /** Unix timestamp when the value was cached */
+  timestamp: number;
+}
+
+/**
+ * Cache storage structure
+ * @interface Cache
+ */
+export interface Cache {
+  [key: string]: CacheEntry;
+}
+
+/**
+ * Loads cache from disk
+ * @returns {Cache} Cached data or empty object if cache doesn't exist or is corrupted
+ */
+export function loadCache(): Cache {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      return JSON.parse(fs.readFileSync(CACHE_FILE, "utf8"));
+    }
+  } catch (error) {
+    // Corrupted cache - return empty object
+  }
+  return {};
+}
+
+/**
+ * Saves cache to disk
+ * @param {Cache} cache - Cache object to save
+ */
+export function saveCache(cache: Cache): void {
+  try {
+    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
+ */
+export 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
+ */
+export 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
+ */
+export function setCachedValue(cache: Cache, key: string, value: any): void {
+  cache[key] = {
+    value,
+    timestamp: Date.now(),
+  };
+}

package/src/info/hardware.ts

@@ -0,0 +1,173 @@
+/**
+ * Hardware-related system information functions
+ * @module info/hardware
+ */
+
+import os from "os";
+import fs from "fs";
+import type { InfoContext } from "../types/internal-types";
+import { IS_WINDOWS, IS_LINUX } from "../utils/platform";
+import { execCommand } from "../utils/command";
+import { getCachedValue, setCachedValue } from "../cache/cache";
+
+/**
+ * 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"
+ */
+export function 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"
+ */
+export function 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 screen resolution from X11 display
+ * Uses xrandr command (Linux with X11/Xorg only)
+ * @returns Resolution in WIDTHxHEIGHT format or empty string
+ * @example "1920x1080", "2560x1440", "3840x2160"
+ */
+export function 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 "";
+}

package/src/info/memory.ts

@@ -0,0 +1,215 @@
+/**
+ * Memory and disk-related system information functions
+ * @module info/memory
+ */
+
+import os from "os";
+import fs from "fs";
+import type { InfoContext } from "../types/internal-types";
+import { IS_LINUX } from "../utils/platform";
+import { execCommand } from "../utils/command";
+import { getCachedValue, setCachedValue } from "../cache/cache";
+
+/**
+ * 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"
+ */
+export function 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 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"
+ */
+export function 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"
+ */
+export function 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 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%"
+ */
+export function 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 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"
+ */
+export function 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 mounted filesystem information
+ * Lists non-system mount points with usage from df (Linux only)
+ * Excludes /, /dev, /proc, and /sys mounts
+ * @param context - Info context with cache
+ * @returns Space-separated mount points with usage or empty string
+ * @example "/home(45%) /mnt/data(78%)", "/media/usb(12%)"
+ */
+export function 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 "";
+}

package/src/info/network.ts

@@ -0,0 +1,213 @@
+/**
+ * Network-related system information functions
+ * @module info/network
+ */
+
+import os from "os";
+import type { InfoContext } from "../types/internal-types";
+import { IS_LINUX } from "../utils/platform";
+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
+ * @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;
+}
+
+/**
+ * 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"
+ */
+export function 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"
+ */
+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;
+}
+
+/**
+ * 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"
+ */
+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;
+}
+
+/**
+ * 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"
+ */
+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;
+}
+
+/**
+ * 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"
+ */
+export function 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 "";
+}
+/**
+ * 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"
+ */
+export function 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 "";
+}