about-system 0.0.40 → 0.0.45

package/src/info/memory.ts

@@ -6,7 +6,7 @@
 import os from "os";
 import fs from "fs";
 import type { InfoContext } from "../types/internal-types";
-import { IS_LINUX } from "../utils/platform";
+import { IS_LINUX, IS_MAC } from "../utils/platform";
 import { execCommand } from "../utils/command";
 import { getCachedValue, setCachedValue } from "../cache/cache";
 
@@ -56,56 +56,101 @@ export function ram_used(context: InfoContext): string {
 
 /**
  * Gets available memory in gigabytes
- * Reads MemAvailable from /proc/meminfo (Linux only)
+ * Reads MemAvailable from /proc/meminfo (Linux) or derives it from
+ * vm_stat's free+inactive pages (macOS)
  * @returns Available memory with "GB available" suffix or empty string
  * @example "12GB available", "4GB available"
  */
 export function memory_available(): string {
-  if (!IS_LINUX) return "";
+  if (IS_LINUX) {
+    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 "";
+  }
+
+  if (IS_MAC) {
+    try {
+      const vmStat = execCommand("vm_stat");
+      const pageSizeMatch = vmStat.match(/page size of (\d+) bytes/);
+      const freeMatch = vmStat.match(/Pages free:\s+(\d+)\./);
+      const inactiveMatch = vmStat.match(/Pages inactive:\s+(\d+)\./);
+
+      if (pageSizeMatch && freeMatch && inactiveMatch) {
+        const pageSize = parseInt(pageSizeMatch[1]);
+        const availablePages = parseInt(freeMatch[1]) + parseInt(inactiveMatch[1]);
+        const availableGB = Math.round((availablePages * pageSize) / (1024 * 1024 * 1024));
+        return `${availableGB}GB available`;
+      }
+    } catch {}
+    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)
+ * Calculates swap usage from /proc/meminfo (Linux) or `sysctl vm.swapusage`
+ * (macOS)
  * @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 "";
+  if (IS_LINUX) {
+    try {
+      const meminfo = fs.readFileSync("/proc/meminfo", "utf8");
+      const swapTotalMatch = meminfo.match(/SwapTotal:\s+(\d+) kB/);
+      const swapFreeMatch = meminfo.match(/SwapFree:\s+(\d+) kB/);
 
-  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`;
+      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 {}
+    } catch {}
+    return "";
+  }
+
+  if (IS_MAC) {
+    try {
+      const swapusage = execCommand("sysctl -n vm.swapusage");
+      const match = swapusage.match(
+        /total\s*=\s*([\d.]+)M\s+used\s*=\s*([\d.]+)M\s+free\s*=\s*([\d.]+)M/
+      );
+
+      if (match) {
+        const swapTotal = parseFloat(match[1]);
+        const swapUsedMB = parseFloat(match[2]);
+
+        if (swapTotal > 0) {
+          const swapUsedPercent = Math.round((swapUsedMB / swapTotal) * 100);
+          return `${swapUsedPercent}% (${Math.round(swapUsedMB)}MB) swap`;
+        }
+
+        return "0% (0MB) swap";
+      }
+    } catch {}
+    return "";
+  }
+
   return "";
 }
 
 /**
  * Gets root filesystem disk usage percentage
- * Uses df command on Linux/Android
+ * Uses df command on Linux/Android/macOS
  * @param context - Info context with cache
  * @returns Percentage string or empty string
  * @example "45%", "78%"
@@ -114,7 +159,7 @@ export function disk_used(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "disk_used");
   if (cached !== null) return cached;
 
-  if (IS_LINUX) {
+  if (IS_LINUX || IS_MAC) {
     try {
       const df = execCommand("df -h");
       let diskUsage = "";
@@ -151,35 +196,108 @@ export function disk_used(context: InfoContext): string {
 }
 
 /**
- * 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"
+ * Minimum total size (in KB) for a partition to be considered a real disk
+ * rather than a small system/boot partition
  */
-export function load_average(): string {
-  if (!IS_LINUX) return "";
+const MIN_REAL_DISK_KB = 10 * 1024 * 1024; // 10GB
+
+/**
+ * Gets disk size (used/total) for each real disk
+ * Uses `df -k` on Linux/macOS, filtering out pseudo filesystems, system/boot
+ * partitions (e.g. /boot, /System/Volumes/*), and anything under 10GB, since
+ * those aren't disks a user would care about. When exactly one real disk is
+ * found (the common case) the result omits the mount point; when multiple
+ * real disks are found (e.g. a data drive or external volume), each is
+ * labeled by its mount point.
+ * @param context - Info context with cache
+ * @returns Disk size as "used/total GB" or "mount(used/total GB) ..." or empty string
+ * @example "256/512GB", "/(100/500GB) /Volumes/Backup(900/2000GB)"
+ */
+export function disk_size(context: InfoContext): string {
+  const cached = getCachedValue(context.cache, "disk_size");
+  if (cached !== null) return cached;
+
+  if (!IS_LINUX && !IS_MAC) {
+    setCachedValue(context.cache, "disk_size", "");
+    return "";
+  }
 
   try {
-    const loadavg = fs.readFileSync("/proc/loadavg", "utf8");
-    const loads = loadavg.split(" ").slice(0, 3);
-    return loads.join(" ");
+    const df = execCommand("df -k");
+    const lines = df.trim().split("\n").slice(1);
+    const disks: { mount: string; usedGB: number; totalGB: number }[] = [];
+
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 6) continue;
+
+      const filesystem = parts[0];
+      const totalKB = parseInt(parts[1]);
+      const usedKB = parseInt(parts[2]);
+      const mount = parts[parts.length - 1];
+
+      if (isNaN(totalKB) || isNaN(usedKB) || totalKB < MIN_REAL_DISK_KB) continue;
+
+      if (IS_MAC) {
+        // Only the boot disk ("/") and externally mounted real disks count.
+        // APFS internal system volumes (Data, VM, Preboot, Update, ...) all
+        // live under /System/Volumes and aren't separate physical disks.
+        if (mount !== "/" && !mount.startsWith("/Volumes/")) continue;
+      } else {
+        if (
+          filesystem.startsWith("devtmpfs") ||
+          filesystem.startsWith("tmpfs") ||
+          filesystem === "overlay" ||
+          mount.startsWith("/boot") ||
+          mount.startsWith("/dev") ||
+          mount.startsWith("/proc") ||
+          mount.startsWith("/sys") ||
+          mount.startsWith("/run")
+        ) {
+          continue;
+        }
+      }
+
+      disks.push({
+        mount,
+        usedGB: Math.round(usedKB / (1024 * 1024)),
+        totalGB: Math.round(totalKB / (1024 * 1024)),
+      });
+    }
+
+    let result = "";
+    if (disks.length === 1) {
+      result = `${disks[0].usedGB}/${disks[0].totalGB}GB`;
+    } else if (disks.length > 1) {
+      result = disks
+        .map((d) => `${d.mount}(${d.usedGB}/${d.totalGB}GB)`)
+        .join(" ");
+    }
+
+    setCachedValue(context.cache, "disk_size", result);
+    return result;
   } catch {}
+
+  setCachedValue(context.cache, "disk_size", "");
   return "";
 }
 
 /**
  * Gets mounted filesystem information
- * Lists non-system mount points with usage from df (Linux only)
- * Excludes /, /dev, /proc, and /sys mounts
+ * Lists non-system mount points with usage from df (Linux/macOS)
+ * On Linux, excludes /, /dev, /proc, /sys and internal /System/Volumes mounts.
+ * On macOS, APFS internal volumes (Data, VM, Preboot, Update, ...) all live
+ * under /System/Volumes and are not user-relevant, so only /Volumes (external
+ * disks, network shares, disk images) are reported.
  * @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%)"
+ * @example "/home(45%) /mnt/data(78%)", "/Volumes/Backup(78%)"
  */
 export function mount_points(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "mount_points");
   if (cached !== null) return cached;
 
-  if (!IS_LINUX) {
+  if (!IS_LINUX && !IS_MAC) {
     setCachedValue(context.cache, "mount_points", "");
     return "";
   }
@@ -191,17 +309,29 @@ export function mount_points(context: InfoContext): 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 !== "/"
-        ) {
+      if (parts.length < 2) return;
+
+      const mountPoint = parts[parts.length - 1];
+      const usage = parts.find((part) => /^\d+%$/.test(part)) || "";
+
+      if (!usage) return;
+
+      if (IS_MAC) {
+        // Skip the "Macintosh HD" self-symlink and any other symlink back to /
+        if (mountPoint.startsWith("/Volumes/") && mountPoint !== "/") {
           mountPoints.push(`${mountPoint}(${usage})`);
         }
+        return;
+      }
+
+      if (
+        !mountPoint.startsWith("/dev") &&
+        !mountPoint.startsWith("/proc") &&
+        !mountPoint.startsWith("/sys") &&
+        !mountPoint.startsWith("/System/Volumes") &&
+        mountPoint !== "/"
+      ) {
+        mountPoints.push(`${mountPoint}(${usage})`);
       }
     });
 

package/src/info/network.ts

@@ -5,7 +5,7 @@
 
 import os from "os";
 import type { InfoContext } from "../types/internal-types";
-import { IS_LINUX } from "../utils/platform";
+import { IS_LINUX, IS_MAC } from "../utils/platform";
 import { execCommand } from "../utils/command";
 import { getCachedValue, setCachedValue } from "../cache/cache";
 
@@ -135,16 +135,16 @@ export async function isp(context: InfoContext): Promise<string> {
 
 /**
  * Gets active network interface names
- * Lists non-loopback interfaces with IPv4 addresses (Linux only)
+ * Lists non-loopback interfaces with IPv4 addresses (Linux/macOS only)
  * @param context - Info context with cache
  * @returns Space-separated interface names or empty string
- * @example "eth0 wlan0", "enp0s3"
+ * @example "eth0 wlan0", "en0 en1"
  */
 export function network_interfaces(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "network_interfaces");
   if (cached !== null) return cached;
 
-  if (!IS_LINUX) {
+  if (!IS_LINUX && !IS_MAC) {
     setCachedValue(context.cache, "network_interfaces", "");
     return "";
   }
@@ -174,7 +174,7 @@ export function network_interfaces(context: InfoContext): string {
 }
 /**
  * Gets open TCP ports with service names
- * Uses lsof to find listening TCP ports (Linux only)
+ * Uses lsof to find listening TCP ports (Linux/macOS only)
  * @param context - Info context with cache
  * @returns Space-separated port+process pairs or empty string
  * @example "80http 443http 22ssh", "3000node 5432post"
@@ -183,7 +183,7 @@ export function ports(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "ports");
   if (cached !== null) return cached;
 
-  if (IS_LINUX) {
+  if (IS_LINUX || IS_MAC) {
     try {
       const lsof = execCommand("lsof -nP -iTCP -sTCP:LISTEN");
       const lines = lsof.split("\n").slice(1);

package/src/info/platform.ts

@@ -50,7 +50,12 @@ export function os_info(context: InfoContext): string {
       osName = `Windows ${release}`;
     }
   } else if (IS_MAC) {
-    osName = `macOS ${release}`;
+    const productName = execCommand("sw_vers -productName");
+    const productVersion = execCommand("sw_vers -productVersion");
+    osName =
+      productName && productVersion
+        ? `${productName} ${productVersion}`
+        : `macOS ${release}`;
   } else if (IS_LINUX) {
     try {
       const osRelease = fs.readFileSync("/etc/os-release", "utf8");
@@ -119,6 +124,14 @@ export function device(context: InfoContext): string {
         return device;
       }
     } catch {}
+  } else if (IS_MAC) {
+    const profile = execCommand("system_profiler SPHardwareDataType");
+    const nameMatch = profile.match(/Model Name:\s*(.+)/);
+    if (nameMatch) {
+      const device = nameMatch[1].trim();
+      setCachedValue(context.cache, "device", device);
+      return device;
+    }
   } else if (IS_LINUX) {
     try {
       if (commandExists("getprop")) {

package/src/info/process.ts

@@ -5,13 +5,13 @@
 
 import os from "os";
 import type { InfoContext } from "../types/internal-types";
-import { IS_LINUX } from "../utils/platform";
+import { IS_LINUX, IS_MAC } 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)
+ * Uses ps command to find top process by CPU usage (Linux/macOS only)
  * @param context - Info context with cache
  * @returns Process info as "percentage processname" or empty string
  * @example "8% firefox", "15% chrome", "3% systemd"
@@ -33,6 +33,22 @@ export function top_process(context: InfoContext): string {
         return result;
       }
     } catch {}
+  } else if (IS_MAC) {
+    try {
+      // -c gives the short command name, -r sorts by %CPU descending
+      const ps = execCommand("ps -Aceo pcpu,comm -r");
+      const lines = ps.split("\n").filter((line) => line.trim());
+      if (lines.length > 1) {
+        const topProcess = lines[1].trim().split(/\s+/);
+        const cpuValue = Math.round(parseFloat(topProcess[0]));
+        const process = topProcess.slice(1).join(" ");
+        if (!isNaN(cpuValue) && process) {
+          const result = `${cpuValue}% ${process}`;
+          setCachedValue(context.cache, "top_process", result);
+          return result;
+        }
+      }
+    } catch {}
   }
 
   setCachedValue(context.cache, "top_process", "");
@@ -54,12 +70,12 @@ export function uptime(): string {
 
 /**
  * Gets number of logged in users
- * Uses who command to count active user sessions (Linux only)
+ * Uses who command to count active user sessions (Linux/macOS 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 "";
+  if (!IS_LINUX && !IS_MAC) return "";
 
   try {
     const who = execCommand("who");

package/src/info/settings.ts

@@ -37,6 +37,7 @@ export const DEFAULT_SETTINGS = {
     ["user", "hostname", "os", "device", "kernel", "cpu", "gpu", "bench"],
     [
       "disk_used",
+      "disk_size",
       "ram_used",
       "top_process",
       "uptime",
@@ -44,13 +45,14 @@ export const DEFAULT_SETTINGS = {
       "battery",
       "load_average",
     ],
-    ["ip", "iplocal", "city", "domain", "isp"],
+    ["ip", "iplocal", "city"],
     ["shell", "services_running", "pacman", "containers"],
   ],
   colors: {
     user: "red",
     hostname: "orange",
     disk_used: "purple",
+    disk_size: "purple",
     ram_used: "yellow",
     top_process: "magenta",
     uptime: "cyan",
@@ -97,6 +99,7 @@ export const DEFAULT_SETTINGS = {
     shell: "🐚 ",
     pacman: "🚀 ",
     disk_used: "📁 ",
+    disk_size: "💽 ",
     ram_used: "💾 ",
     top_process: "🔝 ",
     uptime: "⏱️ ",
@@ -131,6 +134,7 @@ export const DEFAULT_SETTINGS = {
     shell: "Shell",
     pacman: "Packages",
     disk_used: "Disk",
+    disk_size: "Disk Size",
     ram_used: "RAM",
     top_process: "Top",
     uptime: "Uptime",
@@ -150,7 +154,7 @@ export const DEFAULT_SETTINGS = {
   },
   display: {
     show_emojis: true,
-    single_line: false,
+    single_line: true,
     line_wrap_length: process?.stdout?.columns || 100,
   },
   network: {
@@ -168,6 +172,7 @@ export interface Settings {
   labels: Record<string, string>;
   display: {
     show_emojis: boolean;
+    /** true: print one continuous line and let the terminal soft-wrap it; false: hard-wrap at line_wrap_length */
     single_line: boolean;
     line_wrap_length: number;
   };

package/src/info/software.ts

@@ -3,15 +3,17 @@
  * @module info/software
  */
 
+import os from "os";
 import process from "process";
 import type { InfoContext } from "../types/internal-types";
-import { IS_LINUX } from "../utils/platform";
+import { IS_WINDOWS } 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)
+ * Uses the user's login shell (macOS/Linux), falls back to ps for the
+ * parent process shell
  * @returns Shell name or empty string on Windows
  * @example "bash", "zsh", "fish", "nu"
  */
@@ -19,7 +21,16 @@ export function shell(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "shell");
   if (cached !== null) return cached;
 
-  if (IS_LINUX) {
+  if (!IS_WINDOWS) {
+    try {
+      const loginShell = os.userInfo().shell;
+      if (loginShell) {
+        const shellName = loginShell.split("/").pop() as string;
+        setCachedValue(context.cache, "shell", shellName);
+        return shellName;
+      }
+    } catch {}
+
     try {
       const ppid = process.ppid;
       const shellName = execCommand(`ps -p ${ppid} -o comm=`).split("/").pop();
@@ -47,6 +58,7 @@ export function packages(context: InfoContext): string {
 
   const commands = [
     "apt",
+    "brew",
     "npm",
     "uv",
     "docker",

package/src/info/system-status.ts

@@ -6,17 +6,25 @@
 import fs from "fs";
 import os from "os";
 import type { InfoContext } from "../types/internal-types";
-import { IS_LINUX } from "../utils/platform";
+import { IS_LINUX, IS_MAC } 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)
+ * Reads 1, 5, and 15 minute load averages from /proc/loadavg (Linux) or
+ * os.loadavg() (macOS)
  * @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_MAC) {
+    return os
+      .loadavg()
+      .map((n) => n.toFixed(2))
+      .join(" ");
+  }
+
   if (!IS_LINUX) return "";
 
   try {
@@ -38,6 +46,22 @@ export function battery(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "battery");
   if (cached !== null) return cached;
 
+  if (IS_MAC) {
+    try {
+      const batt = execCommand("pmset -g batt");
+      const percentMatch = batt.match(/(\d+)%/);
+      if (percentMatch) {
+        const isCharging = /;\s*(charging|charged);/i.test(batt);
+        const result = `${percentMatch[1]}%${isCharging ? "+" : ""}`;
+        setCachedValue(context.cache, "battery", result);
+        return result;
+      }
+    } catch {}
+
+    setCachedValue(context.cache, "battery", "");
+    return "";
+  }
+
   if (!IS_LINUX) {
     setCachedValue(context.cache, "battery", "");
     return "";
@@ -68,7 +92,9 @@ export function battery(context: InfoContext): string {
 
 /**
  * Gets system temperature in Celsius
- * Reads from thermal zone or hwmon sensors (Linux only)
+ * Reads from thermal zone or hwmon sensors (Linux), or from the
+ * `osx-cpu-temp` CLI (macOS, if installed via `brew install osx-cpu-temp`) -
+ * macOS has no unprivileged API for this, so nothing is reported without it
  * @param context - Info context with cache
  * @returns Temperature with °C suffix or empty string
  * @example "45°C", "62°C"
@@ -77,6 +103,26 @@ export function temperature(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "temperature");
   if (cached !== null) return cached;
 
+  if (IS_MAC) {
+    if (commandExists("osx-cpu-temp")) {
+      try {
+        const output = execCommand("osx-cpu-temp");
+        const match = output.match(/([\d.]+)\s*°?C/);
+        if (match) {
+          const tempC = Math.round(parseFloat(match[1]));
+          if (tempC > 0 && tempC < 150) {
+            const result = `${tempC}°C`;
+            setCachedValue(context.cache, "temperature", result);
+            return result;
+          }
+        }
+      } catch {}
+    }
+
+    setCachedValue(context.cache, "temperature", "");
+    return "";
+  }
+
   if (!IS_LINUX) {
     setCachedValue(context.cache, "temperature", "");
     return "";
@@ -118,6 +164,24 @@ export function services_running(context: InfoContext): string {
   const cached = getCachedValue(context.cache, "services_running");
   if (cached !== null) return cached;
 
+  if (IS_MAC) {
+    try {
+      const services = execCommand("launchctl list");
+      const serviceCount = services
+        .split("\n")
+        .filter((line) => line.trim() && !line.startsWith("PID")).length;
+
+      if (serviceCount > 0) {
+        const result = `${serviceCount} services`;
+        setCachedValue(context.cache, "services_running", result);
+        return result;
+      }
+    } catch {}
+
+    setCachedValue(context.cache, "services_running", "");
+    return "";
+  }
+
   if (!IS_LINUX) {
     setCachedValue(context.cache, "services_running", "");
     return "";