@fredlackey/devutils 0.0.1

package/src/utils/common/apps.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+/**
+ * Generic Application Detection Utilities
+ *
+ * Cross-platform utilities for detecting installed applications.
+ * Delegates to OS-specific implementations for actual detection.
+ */
+
+const osUtils = require('./os');
+const shell = require('./shell');
+
+/**
+ * Cross-platform check if an application is installed
+ * Delegates to OS-specific implementations
+ * @param {string} appName - The application name to check
+ * @returns {Promise<boolean>}
+ */
+async function isInstalled(appName) {
+  const platform = osUtils.detect();
+
+  switch (platform.type) {
+    case 'macos': {
+      const macosApps = require('../macos/apps');
+      return macosApps.isAppInstalled(appName);
+    }
+    case 'ubuntu':
+    case 'debian':
+    case 'raspbian': {
+      const apt = require('../ubuntu/apt');
+      const snap = require('../ubuntu/snap');
+      // Check both apt and snap
+      const aptInstalled = await apt.isPackageInstalled(appName);
+      if (aptInstalled) return true;
+      const snapInstalled = await snap.isSnapInstalled(appName);
+      return snapInstalled;
+    }
+    case 'windows': {
+      const registry = require('../windows/registry');
+      return registry.isAppInstalled(appName);
+    }
+    default:
+      // Fallback: check if command exists in PATH
+      return shell.commandExists(appName);
+  }
+}
+
+/**
+ * Retrieves the installed version of an application
+ * @param {string} appName - The application name
+ * @returns {Promise<string|null>}
+ */
+async function getVersion(appName) {
+  const platform = osUtils.detect();
+
+  switch (platform.type) {
+    case 'macos': {
+      const macosApps = require('../macos/apps');
+      return macosApps.getAppVersion(appName);
+    }
+    case 'ubuntu':
+    case 'debian':
+    case 'raspbian': {
+      const apt = require('../ubuntu/apt');
+      const snap = require('../ubuntu/snap');
+      // Check apt first
+      const aptVersion = await apt.getPackageVersion(appName);
+      if (aptVersion) return aptVersion;
+      // Then snap
+      const snapVersion = await snap.getSnapVersion(appName);
+      return snapVersion;
+    }
+    case 'windows': {
+      const registry = require('../windows/registry');
+      return registry.getAppVersion(appName);
+    }
+    default:
+      // Fallback: try running appName --version
+      return getVersionFromCommand(appName);
+  }
+}
+
+/**
+ * Returns the installation path of an application
+ * @param {string} appName - The application name
+ * @returns {Promise<string|null>}
+ */
+async function getInstallPath(appName) {
+  const platform = osUtils.detect();
+
+  switch (platform.type) {
+    case 'macos': {
+      const macosApps = require('../macos/apps');
+      return macosApps.getAppBundlePath(appName);
+    }
+    case 'windows': {
+      const registry = require('../windows/registry');
+      return registry.getInstallPath(appName);
+    }
+    default:
+      // Fallback: try to find the executable
+      return shell.which(appName);
+  }
+}
+
+/**
+ * Tries to get version by running the command with --version flag
+ * @param {string} command - The command to check
+ * @returns {Promise<string|null>}
+ */
+async function getVersionFromCommand(command) {
+  const versionFlags = ['--version', '-v', '-V', 'version'];
+
+  for (const flag of versionFlags) {
+    const result = await shell.exec(`${command} ${flag}`);
+    if (result.code === 0 && result.stdout) {
+      // Try to extract version number from output
+      const versionMatch = result.stdout.match(/(\d+\.\d+\.?\d*)/);
+      if (versionMatch) {
+        return versionMatch[1];
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Checks if a command-line tool is available
+ * @param {string} command - The command to check
+ * @returns {boolean}
+ */
+function isCommandAvailable(command) {
+  return shell.commandExists(command);
+}
+
+module.exports = {
+  isInstalled,
+  getVersion,
+  getInstallPath,
+  getVersionFromCommand,
+  isCommandAvailable
+};

package/src/utils/common/display.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+/**
+ * Display and GUI Detection Utilities
+ *
+ * Platform-agnostic utilities for detecting display server availability.
+ * Used to determine if GUI applications can be installed/run.
+ */
+
+const fs = require('fs');
+
+/**
+ * Checks if a display server is available
+ * On macOS: Always true (Aqua/Quartz is always present)
+ * On Windows: Always true (Windows Desktop is always present)
+ * On Linux: Checks for X11 or Wayland display
+ * @returns {boolean}
+ */
+function hasDisplay() {
+  const platform = process.platform;
+
+  // macOS always has a display (Aqua/Quartz)
+  if (platform === 'darwin') {
+    return true;
+  }
+
+  // Windows always has a display (unless running as a service, which is rare)
+  if (platform === 'win32') {
+    return true;
+  }
+
+  // Linux: check for X11 or Wayland
+  if (platform === 'linux') {
+    return hasX11Display() || hasWaylandDisplay();
+  }
+
+  return false;
+}
+
+/**
+ * Checks if running in a headless environment (no GUI)
+ * @returns {boolean}
+ */
+function isHeadless() {
+  return !hasDisplay();
+}
+
+/**
+ * Checks if X11 display is available
+ * @returns {boolean}
+ */
+function hasX11Display() {
+  // Check DISPLAY environment variable
+  if (process.env.DISPLAY) {
+    return true;
+  }
+
+  // Check if X server socket exists
+  const x11SocketPath = '/tmp/.X11-unix';
+  if (fs.existsSync(x11SocketPath)) {
+    try {
+      const sockets = fs.readdirSync(x11SocketPath);
+      return sockets.length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Checks if Wayland display is available
+ * @returns {boolean}
+ */
+function hasWaylandDisplay() {
+  // Check WAYLAND_DISPLAY environment variable
+  if (process.env.WAYLAND_DISPLAY) {
+    return true;
+  }
+
+  // Check if Wayland socket exists in XDG_RUNTIME_DIR
+  const runtimeDir = process.env.XDG_RUNTIME_DIR;
+  if (runtimeDir) {
+    const waylandSocketPath = `${runtimeDir}/wayland-0`;
+    if (fs.existsSync(waylandSocketPath)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Gets the type of display server in use
+ * @returns {'aqua'|'windows'|'x11'|'wayland'|null}
+ */
+function getDisplayType() {
+  const platform = process.platform;
+
+  if (platform === 'darwin') {
+    return 'aqua';
+  }
+
+  if (platform === 'win32') {
+    return 'windows';
+  }
+
+  if (platform === 'linux') {
+    if (hasWaylandDisplay()) {
+      return 'wayland';
+    }
+    if (hasX11Display()) {
+      return 'x11';
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Gets the display variable value (DISPLAY or WAYLAND_DISPLAY)
+ * @returns {string|null}
+ */
+function getDisplayVariable() {
+  if (process.env.WAYLAND_DISPLAY) {
+    return process.env.WAYLAND_DISPLAY;
+  }
+  if (process.env.DISPLAY) {
+    return process.env.DISPLAY;
+  }
+  return null;
+}
+
+/**
+ * Checks if SSH session has X11 forwarding enabled
+ * @returns {boolean}
+ */
+function hasX11Forwarding() {
+  // Check if we're in an SSH session with DISPLAY set
+  if (process.env.SSH_CONNECTION && process.env.DISPLAY) {
+    // DISPLAY typically looks like "localhost:10.0" for X11 forwarding
+    const display = process.env.DISPLAY;
+    return display.includes(':');
+  }
+  return false;
+}
+
+module.exports = {
+  hasDisplay,
+  isHeadless,
+  hasX11Display,
+  hasWaylandDisplay,
+  getDisplayType,
+  getDisplayVariable,
+  hasX11Forwarding
+};

package/src/utils/common/network.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+/**
+ * Network Connectivity Utilities
+ *
+ * Platform-agnostic utilities for checking network connectivity.
+ */
+
+const dns = require('dns');
+const https = require('https');
+const http = require('http');
+
+/**
+ * Checks if the machine has internet connectivity
+ * @param {number} [timeout=5000] - Timeout in milliseconds
+ * @returns {Promise<boolean>}
+ */
+async function isOnline(timeout = 5000) {
+  // Try multiple reliable hosts in case one is blocked
+  const hosts = [
+    'dns.google',
+    'cloudflare.com',
+    '1.1.1.1'
+  ];
+
+  for (const host of hosts) {
+    const reachable = await canReach(host, timeout);
+    if (reachable) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Tests if a specific hostname is reachable
+ * @param {string} hostname - The hostname to check
+ * @param {number} [timeout=5000] - Timeout in milliseconds
+ * @returns {Promise<boolean>}
+ */
+async function canReach(hostname, timeout = 5000) {
+  return new Promise((resolve) => {
+    // First try DNS lookup
+    const timer = setTimeout(() => {
+      resolve(false);
+    }, timeout);
+
+    dns.lookup(hostname, (err) => {
+      clearTimeout(timer);
+      if (err) {
+        resolve(false);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+
+/**
+ * Tests if a URL is reachable via HTTP(S) request
+ * @param {string} url - The URL to check
+ * @param {number} [timeout=5000] - Timeout in milliseconds
+ * @returns {Promise<boolean>}
+ */
+async function canFetch(url, timeout = 5000) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      resolve(false);
+    }, timeout);
+
+    const protocol = url.startsWith('https') ? https : http;
+
+    const req = protocol.get(url, { timeout }, (res) => {
+      clearTimeout(timer);
+      // Consider 2xx and 3xx as success
+      resolve(res.statusCode >= 200 && res.statusCode < 400);
+      res.destroy();
+    });
+
+    req.on('error', () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+
+    req.on('timeout', () => {
+      clearTimeout(timer);
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Gets the public IP address of the machine
+ * @param {number} [timeout=5000] - Timeout in milliseconds
+ * @returns {Promise<string|null>}
+ */
+async function getPublicIP(timeout = 5000) {
+  const services = [
+    'https://api.ipify.org',
+    'https://icanhazip.com',
+    'https://ifconfig.me/ip'
+  ];
+
+  for (const service of services) {
+    try {
+      const ip = await fetchText(service, timeout);
+      if (ip && isValidIP(ip.trim())) {
+        return ip.trim();
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Fetches text content from a URL
+ * @param {string} url - The URL to fetch
+ * @param {number} [timeout=5000] - Timeout in milliseconds
+ * @returns {Promise<string>}
+ */
+async function fetchText(url, timeout = 5000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error('Timeout'));
+    }, timeout);
+
+    const protocol = url.startsWith('https') ? https : http;
+
+    const req = protocol.get(url, { timeout }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        clearTimeout(timer);
+        resolve(data);
+      });
+    });
+
+    req.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+
+    req.on('timeout', () => {
+      clearTimeout(timer);
+      req.destroy();
+      reject(new Error('Timeout'));
+    });
+  });
+}
+
+/**
+ * Validates an IP address format
+ * @param {string} ip - The IP to validate
+ * @returns {boolean}
+ */
+function isValidIP(ip) {
+  // IPv4 regex
+  const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+  // IPv6 regex (simplified)
+  const ipv6Regex = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+
+  if (ipv4Regex.test(ip)) {
+    const parts = ip.split('.');
+    return parts.every((part) => {
+      const num = parseInt(part, 10);
+      return num >= 0 && num <= 255;
+    });
+  }
+
+  return ipv6Regex.test(ip);
+}
+
+module.exports = {
+  isOnline,
+  canReach,
+  canFetch,
+  getPublicIP
+};

package/src/utils/common/os.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+/**
+ * Operating System Detection Utilities
+ *
+ * Platform-agnostic utilities for detecting the current operating system,
+ * architecture, and distribution. Uses Node.js APIs that work identically
+ * on all platforms.
+ */
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detects the current operating system and returns platform details
+ * @returns {{ type: string, packageManager: string|null, distro: string|null }}
+ */
+function detect() {
+  const platform = process.platform;
+  const result = {
+    type: 'unknown',
+    packageManager: null,
+    distro: null
+  };
+
+  if (platform === 'darwin') {
+    result.type = 'macos';
+    result.packageManager = 'brew';
+    result.distro = 'macos';
+    return result;
+  }
+
+  if (platform === 'win32') {
+    // Check for WSL
+    if (process.env.WSL_DISTRO_NAME) {
+      result.type = 'wsl';
+      result.packageManager = 'apt';
+      result.distro = process.env.WSL_DISTRO_NAME.toLowerCase();
+      return result;
+    }
+    result.type = 'windows';
+    result.packageManager = 'winget';
+    result.distro = 'windows';
+    return result;
+  }
+
+  if (platform === 'linux') {
+    // Check for WSL first
+    if (process.env.WSL_DISTRO_NAME) {
+      result.type = 'wsl';
+      result.packageManager = 'apt';
+      result.distro = process.env.WSL_DISTRO_NAME.toLowerCase();
+      return result;
+    }
+
+    // Try to detect Linux distribution
+    const distro = getDistro();
+    result.distro = distro;
+
+    // Debian-based (Ubuntu, Debian, Raspberry Pi OS)
+    if (fs.existsSync('/etc/debian_version')) {
+      if (distro === 'raspbian' || distro === 'raspberry') {
+        result.type = 'raspbian';
+      } else if (distro === 'ubuntu') {
+        result.type = 'ubuntu';
+      } else {
+        result.type = 'debian';
+      }
+      result.packageManager = 'apt';
+      return result;
+    }
+
+    // RHEL-based (Amazon Linux, CentOS, Fedora, RHEL)
+    if (fs.existsSync('/etc/redhat-release')) {
+      if (distro === 'amzn' || distro === 'amazon') {
+        result.type = 'amazon_linux';
+      } else if (distro === 'fedora') {
+        result.type = 'fedora';
+      } else {
+        result.type = 'rhel';
+      }
+      // Use dnf if available, otherwise yum
+      result.packageManager = fs.existsSync('/usr/bin/dnf') ? 'dnf' : 'yum';
+      return result;
+    }
+
+    // Fallback for unknown Linux
+    result.type = 'linux';
+    return result;
+  }
+
+  return result;
+}
+
+/**
+ * Checks if running on Windows (native, not WSL)
+ * @returns {boolean}
+ */
+function isWindows() {
+  return process.platform === 'win32' && !process.env.WSL_DISTRO_NAME;
+}
+
+/**
+ * Checks if running on macOS
+ * @returns {boolean}
+ */
+function isMacOS() {
+  return process.platform === 'darwin';
+}
+
+/**
+ * Checks if running on any Linux distribution
+ * @returns {boolean}
+ */
+function isLinux() {
+  return process.platform === 'linux';
+}
+
+/**
+ * Checks if running inside Windows Subsystem for Linux
+ * @returns {boolean}
+ */
+function isWSL() {
+  return !!process.env.WSL_DISTRO_NAME;
+}
+
+/**
+ * Returns the CPU architecture
+ * @returns {string} - 'x64', 'arm64', 'ia32', etc.
+ */
+function getArch() {
+  return process.arch;
+}
+
+/**
+ * For Linux, returns the specific distribution name
+ * @returns {string|null} - Distribution name (ubuntu, debian, fedora, etc.) or null
+ */
+function getDistro() {
+  if (process.platform !== 'linux') {
+    return null;
+  }
+
+  // Try /etc/os-release first (most modern Linux distros)
+  const osReleasePath = '/etc/os-release';
+  if (fs.existsSync(osReleasePath)) {
+    try {
+      const content = fs.readFileSync(osReleasePath, 'utf8');
+      const idMatch = content.match(/^ID=["']?([^"'\n]+)["']?/m);
+      if (idMatch) {
+        return idMatch[1].toLowerCase();
+      }
+    } catch (err) {
+      // Fall through to other methods
+    }
+  }
+
+  // Try /etc/lsb-release (Ubuntu and some others)
+  const lsbReleasePath = '/etc/lsb-release';
+  if (fs.existsSync(lsbReleasePath)) {
+    try {
+      const content = fs.readFileSync(lsbReleasePath, 'utf8');
+      const idMatch = content.match(/^DISTRIB_ID=["']?([^"'\n]+)["']?/m);
+      if (idMatch) {
+        return idMatch[1].toLowerCase();
+      }
+    } catch (err) {
+      // Fall through
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Returns the home directory path
+ * @returns {string}
+ */
+function getHomeDir() {
+  return os.homedir();
+}
+
+/**
+ * Returns the temporary directory path
+ * @returns {string}
+ */
+function getTempDir() {
+  return os.tmpdir();
+}
+
+module.exports = {
+  detect,
+  isWindows,
+  isMacOS,
+  isLinux,
+  isWSL,
+  getArch,
+  getDistro,
+  getHomeDir,
+  getTempDir
+};