@fredlackey/devutils 0.0.1

package/src/utils/common/package-manager.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+/**
+ * Package Manager Abstraction Utilities
+ *
+ * Cross-platform abstraction layer for package managers.
+ * Provides a unified interface for installing packages across different platforms.
+ */
+
+const osUtils = require('./os');
+const shell = require('./shell');
+
+/**
+ * Returns list of available package managers on current system
+ * @returns {Promise<string[]>}
+ */
+async function getAvailable() {
+  const available = [];
+  const platform = osUtils.detect();
+
+  switch (platform.type) {
+    case 'macos':
+      if (shell.commandExists('brew')) {
+        available.push('brew');
+      }
+      break;
+
+    case 'ubuntu':
+    case 'debian':
+    case 'raspbian':
+      if (shell.commandExists('apt-get')) {
+        available.push('apt');
+      }
+      if (shell.commandExists('snap')) {
+        available.push('snap');
+      }
+      break;
+
+    case 'amazon_linux':
+    case 'rhel':
+    case 'fedora':
+      if (shell.commandExists('dnf')) {
+        available.push('dnf');
+      }
+      if (shell.commandExists('yum')) {
+        available.push('yum');
+      }
+      break;
+
+    case 'windows':
+      if (shell.commandExists('winget')) {
+        available.push('winget');
+      }
+      if (shell.commandExists('choco')) {
+        available.push('choco');
+      }
+      break;
+  }
+
+  // Universal package managers
+  if (shell.commandExists('npm')) {
+    available.push('npm');
+  }
+  if (shell.commandExists('pip') || shell.commandExists('pip3')) {
+    available.push('pip');
+  }
+
+  return available;
+}
+
+/**
+ * Returns the preferred/recommended package manager for current platform
+ * @returns {string|null}
+ */
+function getPreferred() {
+  const platform = osUtils.detect();
+
+  switch (platform.type) {
+    case 'macos':
+      return 'brew';
+    case 'ubuntu':
+    case 'debian':
+    case 'raspbian':
+      return 'apt';
+    case 'amazon_linux':
+    case 'rhel':
+    case 'fedora':
+      return platform.packageManager; // dnf or yum
+    case 'windows':
+      return shell.commandExists('winget') ? 'winget' : 'choco';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Installs a package using the best available package manager
+ * @param {string} packageName - The package to install
+ * @param {Object} [options] - Installation options
+ * @param {string} [options.manager] - Force a specific package manager
+ * @param {boolean} [options.global] - Install globally (for npm/pip)
+ * @param {boolean} [options.cask] - Install as cask (macOS only)
+ * @param {boolean} [options.classic] - Use classic confinement (snap only)
+ * @returns {Promise<{ success: boolean, output: string }>}
+ */
+async function install(packageName, options = {}) {
+  const manager = options.manager || getPreferred();
+
+  if (!manager) {
+    return {
+      success: false,
+      output: 'No package manager available'
+    };
+  }
+
+  let command;
+
+  switch (manager) {
+    case 'brew':
+      if (options.cask) {
+        command = `brew install --cask ${packageName}`;
+      } else {
+        command = `brew install ${packageName}`;
+      }
+      break;
+
+    case 'apt':
+      command = `sudo apt-get install -y ${packageName}`;
+      break;
+
+    case 'snap':
+      if (options.classic) {
+        command = `sudo snap install ${packageName} --classic`;
+      } else {
+        command = `sudo snap install ${packageName}`;
+      }
+      break;
+
+    case 'dnf':
+      command = `sudo dnf install -y ${packageName}`;
+      break;
+
+    case 'yum':
+      command = `sudo yum install -y ${packageName}`;
+      break;
+
+    case 'winget':
+      command = `winget install --accept-package-agreements --accept-source-agreements ${packageName}`;
+      break;
+
+    case 'choco':
+      command = `choco install -y ${packageName}`;
+      break;
+
+    case 'npm':
+      if (options.global) {
+        command = `npm install -g ${packageName}`;
+      } else {
+        command = `npm install ${packageName}`;
+      }
+      break;
+
+    case 'pip':
+      const pip = shell.commandExists('pip3') ? 'pip3' : 'pip';
+      if (options.global) {
+        command = `${pip} install ${packageName}`;
+      } else {
+        command = `${pip} install --user ${packageName}`;
+      }
+      break;
+
+    default:
+      return {
+        success: false,
+        output: `Unknown package manager: ${manager}`
+      };
+  }
+
+  const result = await shell.exec(command);
+  return {
+    success: result.code === 0,
+    output: result.stdout || result.stderr
+  };
+}
+
+/**
+ * Uninstalls a package
+ * @param {string} packageName - The package to uninstall
+ * @param {Object} [options] - Uninstallation options
+ * @param {string} [options.manager] - Force a specific package manager
+ * @returns {Promise<{ success: boolean, output: string }>}
+ */
+async function uninstall(packageName, options = {}) {
+  const manager = options.manager || getPreferred();
+
+  if (!manager) {
+    return {
+      success: false,
+      output: 'No package manager available'
+    };
+  }
+
+  let command;
+
+  switch (manager) {
+    case 'brew':
+      command = `brew uninstall ${packageName}`;
+      break;
+
+    case 'apt':
+      command = `sudo apt-get remove -y ${packageName}`;
+      break;
+
+    case 'snap':
+      command = `sudo snap remove ${packageName}`;
+      break;
+
+    case 'dnf':
+      command = `sudo dnf remove -y ${packageName}`;
+      break;
+
+    case 'yum':
+      command = `sudo yum remove -y ${packageName}`;
+      break;
+
+    case 'winget':
+      command = `winget uninstall ${packageName}`;
+      break;
+
+    case 'choco':
+      command = `choco uninstall -y ${packageName}`;
+      break;
+
+    default:
+      return {
+        success: false,
+        output: `Unknown package manager: ${manager}`
+      };
+  }
+
+  const result = await shell.exec(command);
+  return {
+    success: result.code === 0,
+    output: result.stdout || result.stderr
+  };
+}
+
+/**
+ * Updates package lists
+ * @param {string} [manager] - Specific package manager to update
+ * @returns {Promise<{ success: boolean, output: string }>}
+ */
+async function update(manager) {
+  const pm = manager || getPreferred();
+
+  let command;
+
+  switch (pm) {
+    case 'brew':
+      command = 'brew update';
+      break;
+
+    case 'apt':
+      command = 'sudo apt-get update';
+      break;
+
+    case 'dnf':
+      command = 'sudo dnf check-update';
+      break;
+
+    case 'yum':
+      command = 'sudo yum check-update';
+      break;
+
+    case 'choco':
+      command = 'choco upgrade chocolatey -y';
+      break;
+
+    default:
+      return {
+        success: false,
+        output: `Update not supported for: ${pm}`
+      };
+  }
+
+  const result = await shell.exec(command);
+  // dnf/yum check-update returns 100 if updates are available, not an error
+  const success = result.code === 0 || (pm === 'dnf' || pm === 'yum') && result.code === 100;
+  return {
+    success,
+    output: result.stdout || result.stderr
+  };
+}
+
+module.exports = {
+  getAvailable,
+  getPreferred,
+  install,
+  uninstall,
+  update
+};

package/src/utils/common/privileges.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+/**
+ * Permission and Elevation Checking Utilities
+ *
+ * Platform-agnostic utilities for checking elevated privileges.
+ * Handles root on Unix and Administrator on Windows internally.
+ */
+
+const os = require('os');
+
+/**
+ * Checks if running with elevated privileges
+ * On Unix: checks if running as root (uid 0)
+ * On Windows: checks if running as Administrator
+ * @returns {boolean}
+ */
+function isElevated() {
+  if (process.platform === 'win32') {
+    return isWindowsAdmin();
+  }
+  return isUnixRoot();
+}
+
+/**
+ * Checks if running as root on Unix systems
+ * @returns {boolean}
+ */
+function isUnixRoot() {
+  if (process.platform === 'win32') {
+    return false;
+  }
+  return process.getuid && process.getuid() === 0;
+}
+
+/**
+ * Checks if running as Administrator on Windows
+ * Uses a heuristic since Node.js doesn't have direct API for this
+ * @returns {boolean}
+ */
+function isWindowsAdmin() {
+  if (process.platform !== 'win32') {
+    return false;
+  }
+
+  // Method 1: Try to read a system-protected location
+  const fs = require('fs');
+  try {
+    // Try to list the Windows system config directory
+    // Only administrators can access this
+    fs.readdirSync('C:\\Windows\\System32\\config');
+    return true;
+  } catch {
+    // Not admin or access denied
+  }
+
+  // Method 2: Check for common admin environment indicators
+  // This is less reliable but can be a fallback
+  if (process.env.ADMIN_MODE === 'true') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Determines if a given operation type requires elevation
+ * @param {string} operation - The operation type
+ * @returns {boolean}
+ */
+function requiresElevation(operation) {
+  const elevatedOperations = [
+    'install_system_package',
+    'modify_system_config',
+    'start_system_service',
+    'modify_hosts_file',
+    'install_global_npm',
+    'modify_registry',
+    'add_apt_repository',
+    'enable_systemd_service'
+  ];
+
+  return elevatedOperations.includes(operation);
+}
+
+/**
+ * Gets the username of the current user
+ * @returns {string}
+ */
+function getCurrentUser() {
+  return os.userInfo().username;
+}
+
+/**
+ * Checks if the current user can write to a directory
+ * @param {string} dirPath - The directory path to check
+ * @returns {boolean}
+ */
+function canWriteToDirectory(dirPath) {
+  const fs = require('fs');
+  const path = require('path');
+
+  try {
+    // Try to create a temporary file
+    const testFile = path.join(dirPath, `.write-test-${Date.now()}`);
+    fs.writeFileSync(testFile, '');
+    fs.unlinkSync(testFile);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if the current user can execute a file
+ * @param {string} filePath - The file path to check
+ * @returns {boolean}
+ */
+function canExecute(filePath) {
+  const fs = require('fs');
+
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  isElevated,
+  isUnixRoot,
+  isWindowsAdmin,
+  requiresElevation,
+  getCurrentUser,
+  canWriteToDirectory,
+  canExecute
+};

package/src/utils/common/shell.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+/**
+ * Shell Command Execution Utilities
+ *
+ * Platform-agnostic utilities for executing shell commands. Uses Node.js
+ * child_process APIs that work identically on all platforms. Note that while
+ * these utilities are cross-platform, the commands passed to them may be
+ * platform-specific.
+ */
+
+const { exec: cpExec, execSync: cpExecSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Executes a shell command asynchronously
+ * @param {string} command - The command to execute
+ * @param {Object} [options] - Options for child_process.exec
+ * @param {string} [options.cwd] - Working directory
+ * @param {Object} [options.env] - Environment variables
+ * @param {number} [options.timeout] - Timeout in milliseconds
+ * @param {string} [options.encoding] - Output encoding (default: 'utf8')
+ * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
+ */
+async function exec(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const opts = {
+      encoding: options.encoding || 'utf8',
+      cwd: options.cwd,
+      env: options.env || process.env,
+      timeout: options.timeout,
+      maxBuffer: options.maxBuffer || 10 * 1024 * 1024 // 10MB default
+    };
+
+    cpExec(command, opts, (error, stdout, stderr) => {
+      if (error) {
+        resolve({
+          stdout: stdout || '',
+          stderr: stderr || error.message,
+          code: error.code || 1
+        });
+      } else {
+        resolve({
+          stdout: stdout || '',
+          stderr: stderr || '',
+          code: 0
+        });
+      }
+    });
+  });
+}
+
+/**
+ * Executes a shell command synchronously
+ * @param {string} command - The command to execute
+ * @param {Object} [options] - Options for child_process.execSync
+ * @param {string} [options.cwd] - Working directory
+ * @param {Object} [options.env] - Environment variables
+ * @param {number} [options.timeout] - Timeout in milliseconds
+ * @param {string} [options.encoding] - Output encoding (default: 'utf8')
+ * @returns {string} - stdout as string, or empty string on error
+ */
+function execSync(command, options = {}) {
+  try {
+    const opts = {
+      encoding: options.encoding || 'utf8',
+      cwd: options.cwd,
+      env: options.env || process.env,
+      timeout: options.timeout,
+      maxBuffer: options.maxBuffer || 10 * 1024 * 1024, // 10MB default
+      stdio: ['pipe', 'pipe', 'pipe']
+    };
+
+    return cpExecSync(command, opts).toString().trim();
+  } catch (err) {
+    return '';
+  }
+}
+
+/**
+ * Locates an executable in PATH (pure Node.js implementation)
+ * @param {string} executable - The executable name to find
+ * @returns {string|null} - Full path to executable, or null if not found
+ */
+function which(executable) {
+  const isWindows = process.platform === 'win32';
+  const pathSeparator = isWindows ? ';' : ':';
+  const pathEnv = process.env.PATH || '';
+  const paths = pathEnv.split(pathSeparator);
+
+  // On Windows, also check PATHEXT for executable extensions
+  const pathExt = isWindows
+    ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';')
+    : [''];
+
+  for (const dir of paths) {
+    if (!dir) continue;
+
+    for (const ext of pathExt) {
+      const fullPath = path.join(dir, executable + ext);
+      try {
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile()) {
+          // On Unix, check if file is executable
+          if (!isWindows) {
+            try {
+              fs.accessSync(fullPath, fs.constants.X_OK);
+              return fullPath;
+            } catch {
+              continue;
+            }
+          }
+          return fullPath;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Checks if a command is available in PATH
+ * @param {string} command - The command to check
+ * @returns {boolean}
+ */
+function commandExists(command) {
+  return which(command) !== null;
+}
+
+/**
+ * Spawns a process with streaming output
+ * @param {string} command - The command to run
+ * @param {string[]} [args] - Arguments array
+ * @param {Object} [options] - Spawn options
+ * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
+ */
+async function spawnAsync(command, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const opts = {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      shell: options.shell !== false
+    };
+
+    const child = spawn(command, args, opts);
+    let stdout = '';
+    let stderr = '';
+
+    if (child.stdout) {
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+        if (options.onStdout) {
+          options.onStdout(data.toString());
+        }
+      });
+    }
+
+    if (child.stderr) {
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+        if (options.onStderr) {
+          options.onStderr(data.toString());
+        }
+      });
+    }
+
+    child.on('close', (code) => {
+      resolve({
+        stdout,
+        stderr,
+        code: code || 0
+      });
+    });
+
+    child.on('error', (err) => {
+      resolve({
+        stdout,
+        stderr: stderr || err.message,
+        code: 1
+      });
+    });
+  });
+}
+
+module.exports = {
+  exec,
+  execSync,
+  which,
+  commandExists,
+  spawnAsync
+};