about-system 0.0.17 → 0.0.19

package/src/info/system-status.ts

@@ -0,0 +1,152 @@
+/**
+ * System status and health information functions
+ * @module info/system-status
+ */
+
+import fs from "fs";
+import os from "os";
+import type { InfoContext } from "../types/internal-types";
+import { IS_LINUX } from "../utils/platform";
+import { execCommand, commandExists } from "../utils/command";
+import { getCachedValue, setCachedValue } from "../cache/cache";
+
+/**
+ * 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(context: InfoContext): 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 battery charge level and charging status
+ * Reads from /sys/class/power_supply/BAT0 (Linux laptops only)
+ * @param context - Info context with cache
+ * @returns Battery percentage with optional + for charging, or empty string
+ * @example "85%", "42%+", "100%"
+ */
+export function 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 "";
+}
+
+/**
+ * Gets system temperature in Celsius
+ * Reads from thermal zone or hwmon sensors (Linux only)
+ * @param context - Info context with cache
+ * @returns Temperature with °C suffix or empty string
+ * @example "45°C", "62°C"
+ */
+export function 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 "";
+}
+
+/**
+ * Gets count of running system services
+ * Uses systemctl or service command (Linux only)
+ * @param context - Info context with cache
+ * @returns Service count with "services" suffix or empty string
+ * @example "125 services", "89 services"
+ */
+export function 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 "";
+}

package/src/system-info-api.ts

@@ -0,0 +1,271 @@
+/**
+ * @fileoverview System Information API
+ *
+ * A comprehensive cross-platform system information collection API.
+ * Provides clean JSON data without formatting, suitable for programmatic use.
+ *
+ * @module system-info-api
+ * @author vtempest
+ * @license rights.institute/prosper
+ */
+
+import os from "os";
+import fs from "fs";
+import https from "https";
+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
+ */
+const CACHE_DURATION = {
+  ip: 5 * 60 * 1000,
+  cpu: 24 * 60 * 60 * 1000,
+  gpu: 24 * 60 * 60 * 1000,
+  os: 24 * 60 * 60 * 1000,
+  device: 24 * 60 * 60 * 1000,
+  kernel: 60 * 60 * 1000,
+  pacman: 10 * 60 * 1000,
+  ports: 5 * 60 * 1000,
+  containers: 5 * 60 * 1000,
+  top_process: 5 * 1000,
+  disk_used: 60 * 1000,
+  ram_used: 10 * 1000,
+  services_running: 5 * 60 * 1000,
+  temperature: 30 * 1000,
+  battery: 60 * 1000,
+  network_interfaces: 5 * 60 * 1000,
+  mount_points: 10 * 60 * 1000,
+};
+
+/**
+ * Platform detection constants
+ */
+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
+ */
+interface InfoContext {
+  cache: Cache;
+  ipInfo?: IPInfo;
+}
+
+/**
+ * Loads cache from disk
+ */
+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
+ */
+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
+  }
+}
+
+/**
+ * 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
+ */
+export const infoFunctions = {
+  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
+ */
+export async function getSystemInfo(
+  options: SystemInfoOptions = {}
+): Promise<SystemInfo> {
+  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(),
+    };
+  }
+
+  // Collect all system information
+  const info: Partial<SystemInfo> = {
+    timestamp: new Date().toISOString(),
+    platform: IS_WINDOWS
+      ? "windows"
+      : IS_MAC
+      ? "macos"
+      : IS_LINUX
+      ? "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;
+    }
+  }
+
+  saveCache(cache);
+
+  return info as SystemInfo;
+}
+
+export { loadCache, saveCache };