about-system 0.0.17 → 0.0.19

package/src/info/platform.ts

@@ -0,0 +1,145 @@
+/**
+ * Platform-related system information functions
+ * @module info/platform
+ */
+
+import os from "os";
+import fs from "fs";
+import type { InfoContext } from "../types/internal-types";
+import { IS_WINDOWS, IS_MAC, IS_LINUX } from "../utils/platform";
+import { execCommand, commandExists } from "../utils/command";
+import { getCachedValue, setCachedValue } from "../cache/cache";
+
+/**
+ * Gets the current username
+ * @returns Current system username
+ */
+export function user(): string {
+  return os.userInfo().username;
+}
+
+/**
+ * Gets the system hostname
+ * @returns Computer hostname/network name
+ */
+export function hostname(): string {
+  return os.hostname();
+}
+
+/**
+ * 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"
+ */
+export function os_info(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 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"
+ */
+export function 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 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"
+ */
+export function 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 "";
+}

package/src/info/process.ts

@@ -0,0 +1,72 @@
+/**
+ * Process-related system information functions
+ * @module info/process
+ */
+
+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 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"
+ */
+export function 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"
+ */
+export function 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 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"
+ */
+export function 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 "";
+}

package/src/info/settings.ts

@@ -0,0 +1,209 @@
+/**
+ * Settings configuration and management
+ * @module info/settings
+ */
+
+import path from "path";
+import os from "os";
+import fs from "fs";
+import process from "process";
+
+// Settings file paths
+export const SETTINGS_FILE = path.join(
+  os.homedir(),
+  ".config",
+  "systeminfo-settings.json"
+);
+export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
+
+// Color codes
+export const colors = {
+  reset: "\x1b[0m",
+  red: "\x1b[38;5;196m",
+  orange: "\x1b[38;5;208m",
+  yellow: "\x1b[38;5;226m",
+  green: "\x1b[38;5;46m",
+  blue: "\x1b[38;5;39m",
+  cyan: "\x1b[38;5;51m",
+  purple: "\x1b[38;5;171m",
+  magenta: "\x1b[38;5;213m",
+  gray: "\x1b[38;5;250m",
+  lightblue: "\x1b[38;5;220m",
+};
+
+// Default settings
+export const DEFAULT_SETTINGS = {
+  display_order: [
+    ["user", "hostname", "os", "device", "kernel", "cpu", "gpu"],
+    [
+      "disk_used",
+      "ram_used",
+      "top_process",
+      "uptime",
+      "temperature",
+      "battery",
+      "load_average",
+    ],
+    ["ip", "iplocal", "city", "domain", "isp"],
+    ["shell", "pacman", "services_running", "containers"],
+  ],
+  colors: {
+    user: "red",
+    hostname: "orange",
+    disk_used: "purple",
+    ram_used: "yellow",
+    top_process: "magenta",
+    uptime: "cyan",
+    ip: "green",
+    iplocal: "yellow",
+    city: "green",
+    domain: "gray",
+    isp: "lightblue",
+    os: "gray",
+    cpu: "orange",
+    gpu: "yellow",
+    device: "yellow",
+    kernel: "green",
+    shell: "orange",
+    pacman: "multicolor",
+    ports: "multicolor",
+    containers: "green",
+    memory_available: "blue",
+    swap_used: "purple",
+    load_average: "red",
+    users_logged_in: "cyan",
+    network_interfaces: "yellow",
+    mount_points: "gray",
+    services_running: "green",
+    temperature: "red",
+    battery: "green",
+    screen_resolution: "blue",
+  },
+  emojis: {
+    user: "👤 ",
+    hostname: "🏠 ",
+    ip: "🌎 ",
+    iplocal: "🌐 ",
+    city: "📍 ",
+    domain: "🔗 ",
+    isp: "👮 ",
+    os: "⚡ ",
+    cpu: "📈 ",
+    gpu: "🎮 ",
+    device: "💻 ",
+    kernel: "🔧 ",
+    shell: "🐚 ",
+    pacman: "🚀 ",
+    disk_used: "📁 ",
+    ram_used: "💾 ",
+    top_process: "🔝 ",
+    uptime: "⏱️ ",
+    ports: "🔌 ",
+    containers: "📦 ",
+    memory_available: "🧠 ",
+    swap_used: "🔄 ",
+    load_average: "⚖️ ",
+    users_logged_in: "👥 ",
+    network_interfaces: "🌐 ",
+    mount_points: "📂 ",
+    services_running: "⚙️ ",
+    temperature: "🌡️ ",
+    battery_charging: "🔌 ",
+    battery: "🔋 ",
+    screen_resolution: "🖥️ ",
+  },
+  labels: {
+    user: "User",
+    hostname: "Host",
+    ip: "IP",
+    iplocal: "Local IP",
+    city: "City",
+    domain: "Domain",
+    isp: "ISP",
+    os: "OS",
+    cpu: "CPU",
+    gpu: "GPU",
+    device: "Device",
+    kernel: "Kernel",
+    shell: "Shell",
+    pacman: "Packages",
+    disk_used: "Disk",
+    ram_used: "RAM",
+    top_process: "Top",
+    uptime: "Uptime",
+    ports: "Ports",
+    containers: "Containers",
+    memory_available: "Memory",
+    swap_used: "Swap",
+    load_average: "Load",
+    users_logged_in: "Users",
+    network_interfaces: "Network",
+    mount_points: "Mounts",
+    services_running: "Services",
+    temperature: "Temp",
+    battery_charging: "Battery",
+    battery: "Battery",
+    screen_resolution: "Resolution",
+  },
+  display: {
+    show_emojis: true,
+    single_line: false,
+    line_wrap_length: process?.stdout?.columns || 100,
+  },
+  network: {
+    show_offline_message: true,
+  },
+  advanced: {
+    debug: false,
+  },
+};
+
+export interface Settings {
+  display_order: string[][];
+  colors: Record<string, string>;
+  emojis: Record<string, string>;
+  labels: Record<string, string>;
+  display: {
+    show_emojis: boolean;
+    single_line: boolean;
+    line_wrap_length: number;
+  };
+  network: {
+    show_offline_message: boolean;
+  };
+  advanced: {
+    debug: boolean;
+  };
+}
+
+/**
+ * Loads settings from the configuration file
+ * @returns Settings object (defaults merged with user settings)
+ */
+export function loadSettings(): Settings {
+  try {
+    if (fs.existsSync(SETTINGS_FILE)) {
+      const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf8"));
+      return { ...DEFAULT_SETTINGS, ...settings };
+    }
+  } catch {}
+  return DEFAULT_SETTINGS;
+}
+
+/**
+ * Saves settings to the configuration file
+ * @param settings - The settings object to save
+ * @returns True if successful, false otherwise
+ */
+export function saveSettings(settings: Settings): boolean {
+  try {
+    const configDir = path.dirname(SETTINGS_FILE);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/info/software.ts

@@ -0,0 +1,192 @@
+/**
+ * Software and package-related system information functions
+ * @module info/software
+ */
+
+import process from "process";
+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 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"
+ */
+export function shell(context: InfoContext): string {
+  const cached = getCachedValue(context.cache, "shell");
+  if (cached !== null) return cached;
+
+  if (IS_LINUX) {
+    try {
+      const ppid = process.ppid;
+      const shellName = execCommand(`ps -p ${ppid} -o comm=`).split("/").pop();
+      if (shellName) {
+        setCachedValue(context.cache, "shell", shellName);
+        return shellName;
+      }
+    } catch {}
+  }
+
+  setCachedValue(context.cache, "shell", "");
+  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"
+ */
+export function packages(context: InfoContext): string {
+  const cached = getCachedValue(context.cache, "packages");
+  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, "packages", result);
+  return result;
+}
+
+/**
+ * Gets versions of common software tools
+ * @param context - Info context with cache
+ * @returns Formatted string of tool versions
+ * @example "node:20.1.0 git:2.34.1"
+ */
+export function common_versions(context: InfoContext): string {
+  const cached = getCachedValue(context.cache, "common_versions");
+  if (cached !== null) return cached;
+
+  const tools = [
+    {
+      cmd: "node",
+      args: "--version",
+      clean: (v: string) => v.replace(/^v/, ""),
+    },
+    {
+      cmd: "git",
+      args: "--version",
+      clean: (v: string) => v.replace("git version ", ""),
+    },
+    {
+      cmd: "docker",
+      args: "--version",
+      clean: (v: string) => v.replace(/Docker version ([^,]+),.*/, "$1"),
+    },
+    {
+      cmd: "python3",
+      args: "--version",
+      clean: (v: string) => v.replace("Python ", ""),
+    },
+    {
+      cmd: "go",
+      args: "version",
+      clean: (v: string) => v.replace("go version go", "").split(" ")[0],
+    },
+    {
+      cmd: "rustc",
+      args: "--version",
+      clean: (v: string) => v.replace("rustc ", "").split(" ")[0],
+    },
+  ];
+
+  const versions: string[] = [];
+
+  for (const tool of tools) {
+    if (commandExists(tool.cmd)) {
+      try {
+        const output = execCommand(`${tool.cmd} ${tool.args}`);
+        const version = tool.clean(output).trim();
+        if (version) {
+          versions.push(`${tool.cmd}:${version}`);
+        }
+      } catch {}
+    }
+  }
+
+  const result = versions.join(" ");
+  setCachedValue(context.cache, "common_versions", result);
+  return result;
+}
+/**
+ * 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"
+ */
+export function 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 "";
+}