about-system 0.0.17 → 0.0.19

package/package.json

@@ -1,28 +1,41 @@
 {
   "name": "about-system",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "A Node.js script to display key system information with emojis. Cross-platform support for Windows, macOS, and Linux with customizable output and caching.",
-  "main": "src/about-system.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
-    "about-system": "./src/about-system.js",
-    "test-speed": "./src/test-speed-cloudflare.js"
+    "about-system": "./dist/about-system-cli.js"
   },
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/systeminfo-types.d.ts",
-      "import": "./src/about-system.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/system-info-api.d.ts",
+      "import": "./dist/system-info-api.js"
+    },
+    "./cli": {
+      "types": "./dist/about-system-cli.d.ts",
+      "import": "./dist/about-system-cli.js"
+    },
+    "./types": {
+      "types": "./src/systeminfo-types.d.ts"
     }
   },
   "scripts": {
-    "ship": "npx standard-version --release-as patch; npm publish",
-    "start": "node src/about-system.js",
-    "test-speed": "node src/test-speed-cloudflare.js",
-    "install-greeting": "node src/about-system.js --install",
-    "show-settings": "node src/about-system.js --settings-show",
-    "reset-settings": "node src/about-system.js --settings-reset",
-    "clear-cache": "node src/about-system.js --cache-clear",
-    "help": "node src/about-system.js --help"
+    "build": "vite build",
+    "build:tsc": "tsc",
+    "dev": "vite build --watch",
+    "ship": "npm run build && npx standard-version --release-as patch; rm CHANGELOG.md; npm publish",
+    "start": "npm run build && node dist/about-system-cli.js",
+    "install-greeting": "npm run build && node dist/about-system-cli.js --install",
+    "show-settings": "npm run build && node dist/about-system-cli.js --settings-show",
+    "reset-settings": "npm run build && node dist/about-system-cli.js --settings-reset",
+    "clear-cache": "npm run build && node dist/about-system-cli.js --refresh",
+    "help": "npm run build && node dist/about-system-cli.js --help"
   },
   "keywords": [
     "src/about-system",
@@ -47,7 +60,8 @@
   },
   "homepage": "https://github.com/OpenSourceAGI/StarterDOCS/tree/master/packages/about-system-info",
   "files": [
-    "src/about-system.js",
+    "dist/**/*",
+    "src/**/*.ts",
     "README.md",
     "package.json"
   ],
@@ -62,6 +76,12 @@
     "bin": "."
   },
   "dependencies": {
-    "ora": "^8.2.0"
+    "ora": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
   }
 }

package/src/about-system-cli.ts

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+import os from "os";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getSystemInfo } from "./system-info-api";
+import type { SystemInfo, SystemInfoOptions } from "./systeminfo-types";
+
+const __filename = fileURLToPath(import.meta.url);
+
+import {
+  Settings,
+  DEFAULT_SETTINGS,
+  colors,
+  SETTINGS_FILE,
+  CACHE_FILE,
+  loadSettings,
+  saveSettings,
+} from "./info/settings";
+
+// Platform detection
+const IS_WINDOWS = os.platform() === "win32";
+
+function formatValue(key: string, value: string, settings: Settings): string {
+  if (!value || value.trim() === "") return "";
+
+  const color =
+    colors[settings.colors[key] as keyof typeof colors] || colors.reset;
+  const emoji = settings.display.show_emojis ? settings.emojis[key] || "" : "";
+
+  // Special handling for battery emoji
+  if (key === "battery" && settings.display.show_emojis) {
+    const batteryEmoji = value.includes("+")
+      ? settings.emojis.battery_charging
+      : settings.emojis.battery;
+    return `${color}${batteryEmoji}${value}`;
+  }
+
+  // Multicolor handling for ports
+  if (key === "ports" && settings.colors[key] === "multicolor" && value) {
+    const emoji = settings.display.show_emojis ? settings.emojis.ports : "";
+    let output = ` ${emoji}`;
+    const ports = value.split(" ");
+    const colorCodes = [31, 32, 33, 34, 35, 36];
+    ports.forEach((port, index) => {
+      const colorCode = colorCodes[index % colorCodes.length];
+      output += `\x1b[${colorCode}m${port}\x1b[0m `;
+    });
+    return output.trim();
+  }
+
+  // Multicolor handling for pacman
+  if (key === "pacman" && settings.colors[key] === "multicolor" && value) {
+    const emoji = settings.display.show_emojis ? settings.emojis.pacman : "";
+    return `${color}${emoji}${value}`;
+  }
+
+  return `${color}${emoji}${value}`;
+}
+
+function removeAnsiCodes(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+async function displaySystemInfo(
+  customDisplayOrder: string[][] | null = null
+): Promise<void> {
+  const settings = loadSettings();
+  const displayOrder = customDisplayOrder || settings.display_order;
+
+  // Get system info
+  const info = await getSystemInfo();
+
+  // Single line mode
+  if (settings.display.single_line) {
+    const allItems: string[] = [];
+
+    for (const group of displayOrder) {
+      for (const key of group) {
+        const value = info[key as keyof SystemInfo] as string;
+        const formatted = formatValue(key, value, settings);
+        if (formatted && formatted.trim()) {
+          allItems.push(formatted);
+        }
+      }
+    }
+
+    if (allItems.length > 0) {
+      console.log(allItems.join(" ") + colors.reset);
+    }
+    return;
+  }
+
+  // Multi-line mode with intelligent wrapping
+  const lines: string[] = [];
+  let currentLine = "";
+  const maxLineLength = settings.display.line_wrap_length;
+
+  for (const group of displayOrder) {
+    for (const key of group) {
+      const value = info[key as keyof SystemInfo] as string;
+      const formatted = formatValue(key, value, settings);
+
+      if (formatted && formatted.trim()) {
+        const formattedLength = removeAnsiCodes(formatted).length;
+        const currentLineLength = removeAnsiCodes(currentLine).length;
+
+        if (
+          currentLine &&
+          currentLineLength + formattedLength + 1 > maxLineLength
+        ) {
+          lines.push(currentLine);
+          currentLine = formatted;
+        } else {
+          currentLine = currentLine ? `${currentLine} ${formatted}` : formatted;
+        }
+      }
+    }
+  }
+
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+
+  // Output
+  if (lines.length > 0) {
+    lines.forEach((line) => {
+      console.log(line + colors.reset);
+    });
+  } else if (settings.advanced.debug) {
+    console.log("No system information could be displayed");
+  }
+}
+
+function handleSettingsCommand(args: string[]): boolean {
+  const settings = loadSettings();
+
+  if (args.includes("--settings-init")) {
+    if (saveSettings(DEFAULT_SETTINGS)) {
+      console.log("Settings initialized with defaults");
+    } else {
+      console.log("Failed to initialize settings");
+    }
+    return true;
+  }
+
+  if (args.includes("--settings-show")) {
+    console.log("Current settings:");
+    console.log(JSON.stringify(settings, null, 2));
+    return true;
+  }
+
+  if (args.includes("--settings-reset")) {
+    if (saveSettings(DEFAULT_SETTINGS)) {
+      console.log("Settings reset to defaults");
+    } else {
+      console.log("Failed to reset settings");
+    }
+    return true;
+  }
+
+  if (args.includes("--refresh")) {
+    try {
+      if (fs.existsSync(CACHE_FILE)) {
+        fs.unlinkSync(CACHE_FILE);
+        console.log("Cache cleared");
+      }
+    } catch (error) {
+      console.error("Error clearing cache:", (error as Error).message);
+    }
+    return true;
+  }
+
+  const setIndex = args.indexOf("--set");
+  if (setIndex !== -1 && args[setIndex + 1] && args[setIndex + 2]) {
+    const key = args[setIndex + 1];
+    const value = args[setIndex + 2];
+
+    try {
+      const parsedValue =
+        value.startsWith("{") || value.startsWith("[")
+          ? JSON.parse(value)
+          : value;
+
+      const keys = key.split(".");
+      let current: any = settings;
+      for (let i = 0; i < keys.length - 1; i++) {
+        if (!current[keys[i]]) current[keys[i]] = {};
+        current = current[keys[i]];
+      }
+      current[keys[keys.length - 1]] = parsedValue;
+
+      if (saveSettings(settings)) {
+        console.log(`Setting ${key} = ${value}`);
+      } else {
+        console.log("Failed to save settings");
+      }
+    } catch (error) {
+      console.error("Error setting value:", (error as Error).message);
+    }
+    return true;
+  }
+
+  return false;
+}
+
+function installShellGreeting(): void {
+  const homeDir = os.homedir();
+
+  let configDir: string, scriptPath: string;
+  if (IS_WINDOWS) {
+    configDir = path.join(homeDir, "AppData", "Local");
+    scriptPath = path.join(configDir, "systeminfo");
+  } else {
+    configDir = path.join(homeDir, ".config");
+    scriptPath = path.join(configDir, "systeminfo");
+  }
+
+  const currentScript = path.resolve(__filename);
+
+  try {
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    fs.copyFileSync(currentScript, scriptPath);
+    if (!IS_WINDOWS) {
+      fs.chmodSync(scriptPath, "755");
+    }
+
+    if (IS_WINDOWS) {
+      console.log("Windows installation:");
+      console.log("1. Script copied to:", scriptPath);
+      console.log("2. To add to PowerShell profile, run:");
+      console.log(`   Add-Content $PROFILE "node '${scriptPath}'"`);
+      console.log(
+        "3. To add to Command Prompt, create a batch file in your startup folder"
+      );
+
+      const startupBat = path.join(configDir, "systeminfo-startup.bat");
+      fs.writeFileSync(startupBat, `@echo off\nnode "${scriptPath}"\n`);
+      console.log("4. Batch file created:", startupBat);
+    } else {
+      try {
+        const hushLoginPath = path.join(homeDir, ".hushlogin");
+        fs.writeFileSync(hushLoginPath, "");
+      } catch {}
+
+      const bashrcPath = path.join(homeDir, ".bashrc");
+      const bashLine = `node ${scriptPath}`;
+
+      if (fs.existsSync(bashrcPath)) {
+        const bashrc = fs.readFileSync(bashrcPath, "utf8");
+        if (!bashrc.includes("systeminfo")) {
+          fs.appendFileSync(bashrcPath, `\n${bashLine}\n`);
+        }
+      } else {
+        fs.writeFileSync(bashrcPath, `${bashLine}\n`);
+      }
+
+      const zshrcPath = path.join(homeDir, ".zshrc");
+      if (fs.existsSync(zshrcPath)) {
+        const zshrc = fs.readFileSync(zshrcPath, "utf8");
+        if (!zshrc.includes("systeminfo")) {
+          fs.appendFileSync(zshrcPath, `\n${bashLine}\n`);
+        }
+      }
+
+      const fishConfigPath = path.join(
+        homeDir,
+        ".config",
+        "fish",
+        "config.fish"
+      );
+      if (fs.existsSync(fishConfigPath)) {
+        const fishConfig = fs.readFileSync(fishConfigPath, "utf8");
+        if (!fishConfig.includes("systeminfo")) {
+          fs.appendFileSync(
+            fishConfigPath,
+            `\nset -U fish_greeting ""\n${bashLine}\n`
+          );
+        }
+      }
+
+      const nushellConfigPath = path.join(
+        homeDir,
+        ".config",
+        "nushell",
+        "config.nu"
+      );
+      if (fs.existsSync(nushellConfigPath)) {
+        const nushellConfig = fs.readFileSync(nushellConfigPath, "utf8");
+        if (!nushellConfig.includes("systeminfo")) {
+          fs.appendFileSync(
+            nushellConfigPath,
+            `\n$env.config.show_banner = false\n${bashLine}\n`
+          );
+        }
+      }
+    }
+
+    console.log("Shell greeting installation completed!");
+  } catch (error) {
+    console.error("Error installing shell greeting:", (error as Error).message);
+    process.exit(1);
+  }
+}
+
+function parseCLIMode(args: string[]): string[] | null {
+  for (const arg of args) {
+    if (!arg.startsWith("--") && arg.includes(",")) {
+      return arg
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    }
+  }
+
+  for (const arg of args) {
+    if (!arg.startsWith("--") && !arg.includes("=") && arg.length > 0) {
+      return [arg.trim()];
+    }
+  }
+
+  return null;
+}
+
+async function showHelp(): Promise<void> {
+  console.log(`
+System Info Script - TypeScript Version
+
+Usage:
+  about-system [options]
+  about-system <part1,part2,...>    # CLI mode: show specific parts only
+
+Options:
+  --help, -h           Show this help message
+  --install            Install as shell greeting
+  --settings-init      Initialize settings file with defaults
+  --settings-show      Display current settings
+  --settings-reset     Reset settings to defaults
+  --refresh            Clear the cache file
+  --set <key> <value>  Set a configuration value (use dot notation)
+  --json               Output as JSON
+
+Examples:
+  about-system                      # Show all info (default)
+  about-system cpu,os               # Show only CPU and OS info
+  about-system user,hostname,ip     # Show user, hostname, and IP
+  about-system disk_used            # Show only disk usage
+  about-system --install
+  about-system --set display.show_emojis false
+  about-system --set colors.user blue
+  about-system --set emojis.cpu "🚀 "
+  about-system --set labels.cpu "Processor"
+  about-system --json
+
+Settings file: ${SETTINGS_FILE}
+Cache file: ${CACHE_FILE}
+
+Platform: ${
+    IS_WINDOWS
+      ? "Windows"
+      : os.platform() === "darwin"
+      ? "macOS"
+      : os.platform() === "linux"
+      ? "Linux"
+      : "Unknown"
+  }
+
+Available display blocks:
+  Basic: user, hostname, uptime, shell, os, kernel, device
+  Resources: disk_used, ram_used, memory_available, swap_used, top_process
+  Network: ip, iplocal, city, domain, isp, network_interfaces
+  Hardware: cpu, gpu, temperature, battery, screen_resolution
+  System: load_average, users_logged_in, mount_points, services_running
+  Tools: pacman, ports, containers
+`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (handleSettingsCommand(args)) {
+    return;
+  }
+
+  if (args.includes("--help") || args.includes("-h")) {
+    await showHelp();
+    return;
+  }
+
+  if (args.includes("--install")) {
+    installShellGreeting();
+    return;
+  }
+
+  if (args.includes("--json")) {
+    const info = await getSystemInfo();
+    console.log(JSON.stringify(info, null, 2));
+    return;
+  }
+
+  const cliParts = parseCLIMode(args);
+  if (cliParts) {
+    const customDisplayOrder = [cliParts];
+    await displaySystemInfo(customDisplayOrder);
+    return;
+  }
+
+  await displaySystemInfo();
+}
+
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});
+
+export { displaySystemInfo, installShellGreeting };

package/src/cache/cache-config.ts

@@ -0,0 +1,68 @@
+/**
+ * Cache configuration and constants
+ * @module cache-config
+ */
+
+import os from "os";
+import path from "path";
+
+/**
+ * Cache file location in system's temporary directory
+ * @constant
+ */
+export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");
+
+/**
+ * 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)
+ */
+export 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,
+};
+
+/**
+ * Default IPInfo.io API token for geolocation
+ * @constant
+ */
+export const DEFAULT_IPINFO_TOKEN = "da2d6cc4baa5d1";
+
+/**
+ * Default network request timeout in milliseconds
+ * @constant
+ */
+export const DEFAULT_NETWORK_TIMEOUT = 5000;

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/index.ts

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Main entry point for about-system package
+ *
+ * Exports the system information API for programmatic use.
+ * For CLI usage, use the 'about-system' command directly.
+ *
+ * @example
+ * ```typescript
+ * import { getSystemInfo } from 'about-system';
+ *
+ * const info = await getSystemInfo();
+ * console.log(info.cpu);
+ * console.log(info.ram_used);
+ * ```
+ */
+
+export { getSystemInfo, loadCache, saveCache } from './system-info-api.js';
+export type { SystemInfo, SystemInfoOptions, Platform, GetSystemInfoFunction, DisplaySystemInfoFunction, PlatformAvailability } from './systeminfo-types.js';