@fredlackey/devutils 0.0.18 → 0.1.0

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

@@ -1,301 +0,0 @@
-#!/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

@@ -1,138 +0,0 @@
-#!/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

@@ -1,261 +0,0 @@
-#!/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
- *
- * On Windows, this also handles App Execution Aliases (used by winget, etc.)
- * which are special reparse points that don't appear as regular files to
- * fs.statSync().isFile(). We fall back to using the 'where' command for these.
- *
- * @param {string} command - The command to check
- * @returns {boolean}
- */
-function commandExists(command) {
-  // First try the file-based check (works for regular executables)
-  if (which(command) !== null) {
-    return true;
-  }
-
-  // On Windows, App Execution Aliases (like winget) don't appear as regular
-  // files to fs.statSync(). Use 'where' command as a fallback.
-  if (process.platform === 'win32') {
-    try {
-      cpExecSync(`where ${command}`, { stdio: 'ignore' });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  return false;
-}
-
-/**
- * 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
-      });
-    });
-  });
-}
-
-/**
- * Spawns an interactive command with terminal passthrough.
- *
- * Use this function for commands that need user interaction, such as:
- * - Commands that prompt for sudo password
- * - Interactive installers that ask questions
- * - Commands that show progress with cursor movement
- *
- * Unlike exec() or spawnAsync(), this function connects the child process
- * directly to the parent's terminal (stdin, stdout, stderr), allowing the
- * user to interact with the command as if they ran it directly.
- *
- * @param {string} command - The command to run (passed to shell)
- * @param {Object} [options] - Options
- * @param {string} [options.cwd] - Working directory for the command
- * @param {Object} [options.env] - Environment variables (defaults to process.env)
- * @returns {Promise<number>} Exit code (0 = success, non-zero = failure)
- *
- * @example
- * // Run an installer that needs sudo password
- * const exitCode = await spawnInteractive('/bin/bash -c "$(curl -fsSL https://example.com/install.sh)"');
- * if (exitCode !== 0) {
- *   console.error('Installation failed');
- * }
- */
-async function spawnInteractive(command, options = {}) {
-  return new Promise((resolve) => {
-    const child = spawn(command, [], {
-      stdio: 'inherit',  // Connect to parent's terminal
-      shell: true,       // Run through shell to support complex commands
-      cwd: options.cwd,
-      env: options.env || process.env
-    });
-
-    child.on('close', (code) => {
-      resolve(code || 0);
-    });
-
-    child.on('error', () => {
-      resolve(1);
-    });
-  });
-}
-
-module.exports = {
-  exec,
-  execSync,
-  which,
-  commandExists,
-  spawnAsync,
-  spawnInteractive
-};