@fredlackey/devutils 0.0.18 → 0.1.0

package/src/utils/ubuntu/apt.js

@@ -1,307 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * APT Package Manager Utilities
- *
- * Ubuntu/Debian-specific utilities for interacting with APT.
- */
-
-const shell = require('../common/shell');
-
-/**
- * Checks if apt is available
- * @returns {boolean}
- */
-function isInstalled() {
-  return shell.commandExists('apt-get');
-}
-
-/**
- * Installs a package via apt-get
- * @param {string} packageName - The package name to install
- * @param {Object} [options] - Installation options
- * @param {boolean} [options.autoConfirm=true] - Automatically confirm installation
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function install(packageName, options = {}) {
-  if (!isInstalled()) {
-    return {
-      success: false,
-      output: 'apt-get is not available'
-    };
-  }
-
-  const autoConfirm = options.autoConfirm !== false ? '-y' : '';
-  // Use DEBIAN_FRONTEND=noninteractive to avoid prompts during installation
-  const result = await shell.exec(`sudo DEBIAN_FRONTEND=noninteractive apt-get install ${autoConfirm} ${packageName}`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Removes an installed package
- * @param {string} packageName - The package name to remove
- * @param {Object} [options] - Removal options
- * @param {boolean} [options.purge=false] - Also remove configuration files
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function remove(packageName, options = {}) {
-  if (!isInstalled()) {
-    return {
-      success: false,
-      output: 'apt-get is not available'
-    };
-  }
-
-  const command = options.purge ? 'purge' : 'remove';
-  // Use DEBIAN_FRONTEND=noninteractive to avoid prompts during removal
-  const result = await shell.exec(`sudo DEBIAN_FRONTEND=noninteractive apt-get ${command} -y ${packageName}`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Runs apt-get update to refresh package lists
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function update() {
-  if (!isInstalled()) {
-    return {
-      success: false,
-      output: 'apt-get is not available'
-    };
-  }
-
-  // Use DEBIAN_FRONTEND=noninteractive to avoid prompts during update
-  const result = await shell.exec('sudo DEBIAN_FRONTEND=noninteractive apt-get update');
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Upgrades a specific package or all packages
- * @param {string} [packageName] - The package to upgrade (all if omitted)
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function upgrade(packageName) {
-  if (!isInstalled()) {
-    return {
-      success: false,
-      output: 'apt-get is not available'
-    };
-  }
-
-  // Use DEBIAN_FRONTEND=noninteractive to avoid prompts during upgrade
-  const command = packageName
-    ? `sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --only-upgrade ${packageName}`
-    : 'sudo DEBIAN_FRONTEND=noninteractive apt-get upgrade -y';
-
-  const result = await shell.exec(command);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Queries dpkg to check if a package is installed
- * @param {string} packageName - The package name to check
- * @returns {Promise<boolean>}
- */
-async function isPackageInstalled(packageName) {
-  const result = await shell.exec(`dpkg -l ${packageName} 2>/dev/null | grep -q "^ii"`);
-  return result.code === 0;
-}
-
-/**
- * Returns the installed version of a package
- * @param {string} packageName - The package name
- * @returns {Promise<string|null>}
- */
-async function getPackageVersion(packageName) {
-  const result = await shell.exec(
-    `dpkg -l ${packageName} 2>/dev/null | grep "^ii" | awk '{print $3}'`
-  );
-  if (result.code === 0 && result.stdout.trim()) {
-    return result.stdout.trim();
-  }
-  return null;
-}
-
-/**
- * Adds an APT repository to sources
- * @param {string} repo - The repository specification
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function addRepository(repo) {
-  if (!shell.commandExists('add-apt-repository')) {
-    // Try to install software-properties-common first
-    // Use DEBIAN_FRONTEND=noninteractive to avoid prompts
-    const installResult = await shell.exec('sudo DEBIAN_FRONTEND=noninteractive apt-get install -y software-properties-common');
-    if (installResult.code !== 0) {
-      return {
-        success: false,
-        output: 'add-apt-repository is not available and could not be installed'
-      };
-    }
-  }
-
-  const result = await shell.exec(`sudo add-apt-repository -y "${repo}"`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Removes an APT repository
- * @param {string} repo - The repository specification
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function removeRepository(repo) {
-  if (!shell.commandExists('add-apt-repository')) {
-    return {
-      success: false,
-      output: 'add-apt-repository is not available'
-    };
-  }
-
-  const result = await shell.exec(`sudo add-apt-repository --remove -y "${repo}"`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Imports a GPG key for package verification from a URL
- * @param {string} keyUrl - The URL of the GPG key
- * @param {string} [keyringPath] - Optional path for the keyring file
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function addKey(keyUrl, keyringPath) {
-  // Modern method using signed-by (recommended for Ubuntu 22.04+)
-  if (keyringPath) {
-    const result = await shell.exec(
-      `curl -fsSL "${keyUrl}" | sudo gpg --dearmor -o "${keyringPath}"`
-    );
-    return {
-      success: result.code === 0,
-      output: result.stdout || result.stderr
-    };
-  }
-
-  // Legacy method using apt-key (deprecated but still works)
-  const result = await shell.exec(
-    `curl -fsSL "${keyUrl}" | sudo apt-key add -`
-  );
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Imports a GPG key from a keyserver
- * @param {string} keyId - The GPG key ID
- * @param {string} [keyserver='keyserver.ubuntu.com'] - The keyserver to use
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function addKeyFromKeyserver(keyId, keyserver = 'keyserver.ubuntu.com') {
-  const result = await shell.exec(
-    `sudo apt-key adv --keyserver ${keyserver} --recv-keys ${keyId}`
-  );
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Searches apt cache for packages
- * @param {string} query - The search query
- * @returns {Promise<string[]>}
- */
-async function search(query) {
-  const result = await shell.exec(`apt-cache search "${query}"`);
-  if (result.code !== 0) {
-    return [];
-  }
-
-  return result.stdout
-    .split('\n')
-    .filter(Boolean)
-    .map((line) => {
-      // Format: "package-name - description"
-      const match = line.match(/^(\S+)\s+-\s+/);
-      return match ? match[1] : line.split(' ')[0];
-    })
-    .filter(Boolean);
-}
-
-/**
- * Gets detailed information about a package
- * @param {string} packageName - The package name
- * @returns {Promise<string|null>}
- */
-async function info(packageName) {
-  const result = await shell.exec(`apt-cache show ${packageName}`);
-  if (result.code === 0) {
-    return result.stdout;
-  }
-  return null;
-}
-
-/**
- * Lists all installed packages
- * @returns {Promise<string[]>}
- */
-async function listInstalled() {
-  const result = await shell.exec('dpkg --get-selections | grep -v deinstall');
-  if (result.code !== 0) {
-    return [];
-  }
-
-  return result.stdout
-    .split('\n')
-    .filter(Boolean)
-    .map((line) => line.split('\t')[0])
-    .filter(Boolean);
-}
-
-/**
- * Cleans up apt cache
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function clean() {
-  // Use DEBIAN_FRONTEND=noninteractive to avoid prompts
-  const result = await shell.exec('sudo DEBIAN_FRONTEND=noninteractive apt-get clean && sudo DEBIAN_FRONTEND=noninteractive apt-get autoremove -y');
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-module.exports = {
-  isInstalled,
-  install,
-  remove,
-  update,
-  upgrade,
-  isPackageInstalled,
-  getPackageVersion,
-  addRepository,
-  removeRepository,
-  addKey,
-  addKeyFromKeyserver,
-  search,
-  info,
-  listInstalled,
-  clean
-};

package/src/utils/ubuntu/desktop.js

@@ -1,292 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Desktop Environment Detection Utilities
- *
- * Linux-specific utilities for detecting desktop environments and display servers.
- * These functions address a Linux-specific concern: Linux has multiple display
- * servers (X11, Wayland) and desktop environments (GNOME, KDE, XFCE, etc.).
- * macOS always uses Aqua/Quartz, and Windows always uses the Windows Desktop.
- */
-
-const fs = require('fs');
-const shell = require('../common/shell');
-
-/**
- * Checks if a desktop environment is installed and running
- * @returns {boolean}
- */
-function hasDesktop() {
-  // Check if any display server is available
-  if (isX11() || isWayland()) {
-    return true;
-  }
-
-  // Check for common desktop environment indicators
-  if (process.env.XDG_CURRENT_DESKTOP) {
-    return true;
-  }
-
-  if (process.env.DESKTOP_SESSION) {
-    return true;
-  }
-
-  // Check if any desktop environment package is installed
-  const desktopPackages = [
-    'ubuntu-desktop',
-    'kubuntu-desktop',
-    'xubuntu-desktop',
-    'lubuntu-desktop',
-    'gnome-shell',
-    'plasma-desktop',
-    'xfce4',
-    'lxde',
-    'mate-desktop'
-  ];
-
-  for (const pkg of desktopPackages) {
-    const result = shell.execSync(`dpkg -l ${pkg} 2>/dev/null | grep -q "^ii"`);
-    if (result !== '') {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Returns the desktop environment name
- * @returns {string|null} - Desktop name (gnome, kde, xfce, etc.) or null
- */
-function getDesktopEnvironment() {
-  // XDG_CURRENT_DESKTOP is the most reliable indicator
-  if (process.env.XDG_CURRENT_DESKTOP) {
-    const desktop = process.env.XDG_CURRENT_DESKTOP.toLowerCase();
-
-    // Normalize common values
-    if (desktop.includes('gnome')) return 'gnome';
-    if (desktop.includes('kde') || desktop.includes('plasma')) return 'kde';
-    if (desktop.includes('xfce')) return 'xfce';
-    if (desktop.includes('lxde')) return 'lxde';
-    if (desktop.includes('lxqt')) return 'lxqt';
-    if (desktop.includes('mate')) return 'mate';
-    if (desktop.includes('cinnamon')) return 'cinnamon';
-    if (desktop.includes('unity')) return 'unity';
-    if (desktop.includes('budgie')) return 'budgie';
-    if (desktop.includes('pantheon')) return 'pantheon';
-
-    return desktop.split(':')[0]; // Take first if multiple (e.g., "ubuntu:GNOME")
-  }
-
-  // Check DESKTOP_SESSION as fallback
-  if (process.env.DESKTOP_SESSION) {
-    const session = process.env.DESKTOP_SESSION.toLowerCase();
-
-    if (session.includes('gnome')) return 'gnome';
-    if (session.includes('kde') || session.includes('plasma')) return 'kde';
-    if (session.includes('xfce')) return 'xfce';
-    if (session.includes('lxde')) return 'lxde';
-    if (session.includes('mate')) return 'mate';
-
-    return session;
-  }
-
-  // Check GNOME_DESKTOP_SESSION_ID (older GNOME)
-  if (process.env.GNOME_DESKTOP_SESSION_ID) {
-    return 'gnome';
-  }
-
-  // Check KDE_FULL_SESSION
-  if (process.env.KDE_FULL_SESSION) {
-    return 'kde';
-  }
-
-  return null;
-}
-
-/**
- * Returns the display server type
- * @returns {'x11'|'wayland'|null}
- */
-function getDisplayServer() {
-  if (isWayland()) {
-    return 'wayland';
-  }
-  if (isX11()) {
-    return 'x11';
-  }
-  return null;
-}
-
-/**
- * Checks if running under X11
- * @returns {boolean}
- */
-function isX11() {
-  // Check XDG_SESSION_TYPE first (most reliable on modern systems)
-  if (process.env.XDG_SESSION_TYPE === 'x11') {
-    return true;
-  }
-
-  // Check DISPLAY environment variable
-  if (process.env.DISPLAY) {
-    // Make sure we're not in Wayland with XWayland
-    if (process.env.WAYLAND_DISPLAY) {
-      return false; // We're in Wayland, DISPLAY is for XWayland compatibility
-    }
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Checks if running under Wayland
- * @returns {boolean}
- */
-function isWayland() {
-  // Check XDG_SESSION_TYPE first
-  if (process.env.XDG_SESSION_TYPE === 'wayland') {
-    return true;
-  }
-
-  // Check WAYLAND_DISPLAY
-  if (process.env.WAYLAND_DISPLAY) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Returns the DISPLAY or WAYLAND_DISPLAY environment value
- * @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;
-}
-
-/**
- * Gets the XDG session type
- * @returns {string|null}
- */
-function getSessionType() {
-  return process.env.XDG_SESSION_TYPE || null;
-}
-
-/**
- * Gets the current session ID
- * @returns {string|null}
- */
-function getSessionId() {
-  return process.env.XDG_SESSION_ID || null;
-}
-
-/**
- * Checks if running in a virtual terminal (TTY) without GUI
- * @returns {boolean}
- */
-function isTTY() {
-  // XDG_SESSION_TYPE is 'tty' for virtual terminals
-  if (process.env.XDG_SESSION_TYPE === 'tty') {
-    return true;
-  }
-
-  // Check if TERM indicates a TTY
-  const term = process.env.TERM || '';
-  if (term === 'linux' || term.startsWith('vt')) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Gets the screen resolution (requires xrandr or similar)
- * @returns {Promise<{ width: number, height: number }|null>}
- */
-async function getScreenResolution() {
-  if (isX11()) {
-    const result = await shell.exec('xrandr 2>/dev/null | grep "\\*" | head -1');
-    if (result.code === 0 && result.stdout) {
-      const match = result.stdout.match(/(\d+)x(\d+)/);
-      if (match) {
-        return {
-          width: parseInt(match[1], 10),
-          height: parseInt(match[2], 10)
-        };
-      }
-    }
-  }
-
-  if (isWayland()) {
-    // Try wlr-randr for wlroots-based compositors
-    const result = await shell.exec('wlr-randr 2>/dev/null | grep "current" | head -1');
-    if (result.code === 0 && result.stdout) {
-      const match = result.stdout.match(/(\d+)x(\d+)/);
-      if (match) {
-        return {
-          width: parseInt(match[1], 10),
-          height: parseInt(match[2], 10)
-        };
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Gets the GNOME Shell version (if running GNOME)
- * @returns {Promise<string|null>}
- */
-async function getGnomeVersion() {
-  if (getDesktopEnvironment() !== 'gnome') {
-    return null;
-  }
-
-  const result = await shell.exec('gnome-shell --version 2>/dev/null');
-  if (result.code === 0) {
-    const match = result.stdout.match(/GNOME Shell (\d+\.\d+\.?\d*)/);
-    return match ? match[1] : null;
-  }
-  return null;
-}
-
-/**
- * Gets the KDE Plasma version (if running KDE)
- * @returns {Promise<string|null>}
- */
-async function getKdeVersion() {
-  if (getDesktopEnvironment() !== 'kde') {
-    return null;
-  }
-
-  const result = await shell.exec('plasmashell --version 2>/dev/null');
-  if (result.code === 0) {
-    const match = result.stdout.match(/plasmashell (\d+\.\d+\.?\d*)/);
-    return match ? match[1] : null;
-  }
-  return null;
-}
-
-module.exports = {
-  hasDesktop,
-  getDesktopEnvironment,
-  getDisplayServer,
-  isX11,
-  isWayland,
-  getDisplayVariable,
-  getSessionType,
-  getSessionId,
-  isTTY,
-  getScreenResolution,
-  getGnomeVersion,
-  getKdeVersion
-};