@fredlackey/devutils 0.0.1 → 0.0.3

package/src/scripts/y.js

@@ -1,23 +1,283 @@
 #!/usr/bin/env node
 
 /**
- * @fileoverview Shortcut for yarn commands.
+ * y - Shortcut for yarn commands
+ *
+ * Migrated from legacy dotfiles alias.
+ * Original: alias y="yarn"
+ *
+ * This script provides a single-character shortcut for the Yarn package manager,
+ * passing all arguments through to the `yarn` command. Yarn is a popular
+ * JavaScript package manager that is an alternative to npm.
+ *
+ * Examples:
+ *   y                  -> yarn (runs default yarn command, typically install)
+ *   y add lodash       -> yarn add lodash
+ *   y remove lodash    -> yarn remove lodash
+ *   y dev              -> yarn dev (runs the "dev" script)
+ *   y build            -> yarn build (runs the "build" script)
+ *   y --version        -> yarn --version
+ *
  * @module scripts/y
  */
 
+const os = require('../utils/common/os');
+const { spawn } = require('child_process');
+const { commandExists } = require('../utils/common/shell');
+
+/**
+ * Pure Node.js implementation that works on any platform.
+ *
+ * This function spawns the `yarn` command with all provided arguments.
+ * It uses spawn with stdio: 'inherit' to:
+ * 1. Pass through all arguments exactly as provided
+ * 2. Preserve colored output from yarn
+ * 3. Allow interactive prompts if yarn needs user input
+ * 4. Properly forward stdin, stdout, and stderr
+ *
+ * The exit code from yarn is preserved and passed to the parent process,
+ * ensuring that CI/CD pipelines and scripts can detect yarn failures.
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y_nodejs(args) {
+  // First, check if yarn is installed
+  if (!commandExists('yarn')) {
+    console.error('Error: yarn is not installed or not in PATH.');
+    console.error('');
+    console.error('To install yarn, you can use one of the following methods:');
+    console.error('');
+    console.error('  Using npm (recommended if you have Node.js):');
+    console.error('    npm install -g yarn');
+    console.error('');
+    console.error('  Using Corepack (Node.js 16.10+):');
+    console.error('    corepack enable');
+    console.error('');
+    console.error('  Using Homebrew (macOS):');
+    console.error('    brew install yarn');
+    console.error('');
+    console.error('  Using apt (Ubuntu/Debian):');
+    console.error('    sudo apt install yarn');
+    console.error('');
+    console.error('For more information, visit: https://yarnpkg.com/getting-started/install');
+    process.exit(1);
+  }
+
+  // Spawn yarn with all arguments, inheriting stdio for full interactivity
+  // This preserves:
+  // - Colored output (yarn uses colors extensively)
+  // - Interactive prompts (e.g., yarn init questions)
+  // - Progress indicators and spinners
+  // - Proper terminal width detection
+  return new Promise((resolve, reject) => {
+    const child = spawn('yarn', args, {
+      stdio: 'inherit',  // Pass through stdin, stdout, stderr
+      shell: false       // Run yarn directly, not through a shell (more efficient)
+    });
+
+    child.on('close', (code) => {
+      // Preserve yarn's exit code so CI/CD can detect failures
+      // Exit code 0 = success, non-zero = failure
+      if (code !== 0) {
+        process.exit(code);
+      }
+      resolve();
+    });
+
+    child.on('error', (err) => {
+      // This typically happens if yarn is not found (though we check above)
+      // or if there's a permission issue
+      console.error(`Error executing yarn: ${err.message}`);
+      process.exit(1);
+    });
+  });
+}
+
+/**
+ * Execute yarn on macOS.
+ *
+ * Uses the pure Node.js implementation since yarn behaves identically
+ * on all platforms - it's a cross-platform tool by design.
+ *
+ * On macOS, yarn is typically installed via:
+ * - npm install -g yarn
+ * - brew install yarn
+ * - Corepack (corepack enable)
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y_macos(args) {
+  return do_y_nodejs(args);
+}
+
+/**
+ * Execute yarn on Ubuntu.
+ *
+ * Uses the pure Node.js implementation since yarn behaves identically
+ * on all platforms - it's a cross-platform tool by design.
+ *
+ * On Ubuntu, yarn is typically installed via:
+ * - npm install -g yarn
+ * - sudo apt install yarn (from official yarn repository)
+ * - Corepack (corepack enable)
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y_ubuntu(args) {
+  return do_y_nodejs(args);
+}
+
+/**
+ * Execute yarn on Raspberry Pi OS.
+ *
+ * Uses the pure Node.js implementation since yarn behaves identically
+ * on all platforms - it's a cross-platform tool by design.
+ *
+ * On Raspberry Pi OS, yarn is typically installed via:
+ * - npm install -g yarn
+ * - Corepack (corepack enable)
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y_raspbian(args) {
+  return do_y_nodejs(args);
+}
+
+/**
+ * Execute yarn on Amazon Linux.
+ *
+ * Uses the pure Node.js implementation since yarn behaves identically
+ * on all platforms - it's a cross-platform tool by design.
+ *
+ * On Amazon Linux, yarn is typically installed via:
+ * - npm install -g yarn
+ * - Corepack (corepack enable)
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y_amazon_linux(args) {
+  return do_y_nodejs(args);
+}
+
+/**
+ * Execute yarn in Windows Command Prompt.
+ *
+ * Uses the pure Node.js implementation since yarn behaves identically
+ * on all platforms - it's a cross-platform tool by design.
+ *
+ * On Windows, yarn is typically installed via:
+ * - npm install -g yarn
+ * - choco install yarn (Chocolatey)
+ * - winget install Yarn.Yarn
+ * - Corepack (corepack enable)
+ *
+ * Note: On Windows, yarn is typically installed as yarn.cmd or yarn.ps1,
+ * but spawn will find it correctly through the PATH.
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y_cmd(args) {
+  return do_y_nodejs(args);
+}
+
 /**
- * Executes yarn with the provided arguments.
- * Acts as a shorthand for common yarn operations.
+ * Execute yarn in Windows PowerShell.
+ *
+ * Uses the pure Node.js implementation since yarn behaves identically
+ * on all platforms - it's a cross-platform tool by design.
  *
  * @param {string[]} args - Command line arguments to pass to yarn
  * @returns {Promise<void>}
  */
-async function main(args) {
-  // TODO: Implement yarn shortcut
+async function do_y_powershell(args) {
+  return do_y_nodejs(args);
+}
+
+/**
+ * Execute yarn in Git Bash on Windows.
+ *
+ * Uses the pure Node.js implementation since yarn behaves identically
+ * on all platforms - it's a cross-platform tool by design.
+ *
+ * Git Bash can access Windows-installed yarn through the PATH.
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y_gitbash(args) {
+  return do_y_nodejs(args);
+}
+
+/**
+ * Main entry point - detects environment and executes appropriate implementation.
+ *
+ * The "y" command is a shortcut for yarn, the JavaScript package manager.
+ * All arguments are passed through to yarn unchanged.
+ *
+ * This script is idempotent by nature - running yarn commands multiple times
+ * will produce consistent results (yarn itself handles idempotency for
+ * operations like install).
+ *
+ * Common usage patterns:
+ *   y                  - Install dependencies (equivalent to yarn install)
+ *   y add <package>    - Add a new dependency
+ *   y remove <package> - Remove a dependency
+ *   y <script>         - Run a script from package.json
+ *   y upgrade          - Upgrade dependencies
+ *   y --help           - Show yarn help
+ *
+ * @param {string[]} args - Command line arguments to pass to yarn
+ * @returns {Promise<void>}
+ */
+async function do_y(args) {
+  const platform = os.detect();
+
+  const handlers = {
+    'macos': do_y_macos,
+    'ubuntu': do_y_ubuntu,
+    'debian': do_y_ubuntu,
+    'raspbian': do_y_raspbian,
+    'amazon_linux': do_y_amazon_linux,
+    'rhel': do_y_amazon_linux,
+    'fedora': do_y_ubuntu,
+    'linux': do_y_ubuntu,
+    'wsl': do_y_ubuntu,
+    'cmd': do_y_cmd,
+    'windows': do_y_cmd,
+    'powershell': do_y_powershell,
+    'gitbash': do_y_gitbash
+  };
+
+  const handler = handlers[platform.type];
+  if (!handler) {
+    // Yarn is cross-platform, so try the Node.js implementation anyway
+    console.error(`Note: Platform '${platform.type}' not explicitly supported, attempting to run yarn...`);
+    await do_y_nodejs(args);
+    return;
+  }
+
+  await handler(args);
 }
 
-module.exports = { main };
+module.exports = {
+  main: do_y,
+  do_y,
+  do_y_nodejs,
+  do_y_macos,
+  do_y_ubuntu,
+  do_y_raspbian,
+  do_y_amazon_linux,
+  do_y_cmd,
+  do_y_powershell,
+  do_y_gitbash
+};
 
 if (require.main === module) {
-  main(process.argv.slice(2));
+  do_y(process.argv.slice(2));
 }

package/src/utils/common/os.js

@@ -72,7 +72,8 @@ function detect() {
     }
 
     // RHEL-based (Amazon Linux, CentOS, Fedora, RHEL)
-    if (fs.existsSync('/etc/redhat-release')) {
+    // Check for /etc/redhat-release OR /etc/system-release (Amazon Linux 2023 uses system-release)
+    if (fs.existsSync('/etc/redhat-release') || fs.existsSync('/etc/system-release')) {
       if (distro === 'amzn' || distro === 'amazon') {
         result.type = 'amazon_linux';
       } else if (distro === 'fedora') {
@@ -189,6 +190,96 @@ function getTempDir() {
   return os.tmpdir();
 }
 
+/**
+ * Checks if a graphical desktop environment is available on the current system.
+ *
+ * This function determines whether GUI applications can be displayed:
+ * - macOS: Always returns true (Aqua/Quartz desktop is always available)
+ * - Windows (native): Always returns true (Windows Desktop is always available)
+ * - Git Bash: Always returns true (runs on Windows which has a desktop)
+ * - Linux: Checks for X11, Wayland, or installed desktop environment packages
+ * - WSL: Checks for WSLg or X server availability via DISPLAY/WAYLAND_DISPLAY
+ *
+ * Use this function before installing GUI applications to ensure the system
+ * can actually display them. Headless servers and containers typically
+ * return false.
+ *
+ * @returns {boolean} True if a desktop environment is available, false otherwise
+ *
+ * @example
+ * const os = require('../utils/common/os');
+ * if (!os.isDesktopAvailable()) {
+ *   console.log('This tool requires a desktop environment.');
+ *   return;
+ * }
+ */
+function isDesktopAvailable() {
+  const platform = detect();
+
+  // macOS always has a desktop environment (Aqua/Quartz)
+  if (platform.type === 'macos') {
+    return true;
+  }
+
+  // Windows (native) always has a desktop environment
+  if (platform.type === 'windows') {
+    return true;
+  }
+
+  // Git Bash runs on Windows, which has a desktop
+  if (platform.type === 'gitbash') {
+    return true;
+  }
+
+  // For Linux-based systems (including WSL), check for display availability
+  // This covers ubuntu, debian, raspbian, amazon_linux, rhel, fedora, wsl
+  if (platform.type === 'wsl' ||
+      platform.type === 'ubuntu' ||
+      platform.type === 'debian' ||
+      platform.type === 'raspbian' ||
+      platform.type === 'amazon_linux' ||
+      platform.type === 'rhel' ||
+      platform.type === 'fedora' ||
+      platform.type === 'linux') {
+
+    // Check for Wayland display (modern Linux desktops)
+    if (process.env.WAYLAND_DISPLAY) {
+      return true;
+    }
+
+    // Check for X11 display
+    if (process.env.DISPLAY) {
+      return true;
+    }
+
+    // Check XDG session type (set by display managers)
+    const sessionType = process.env.XDG_SESSION_TYPE;
+    if (sessionType === 'x11' || sessionType === 'wayland') {
+      return true;
+    }
+
+    // Check for desktop environment indicators
+    if (process.env.XDG_CURRENT_DESKTOP || process.env.DESKTOP_SESSION) {
+      return true;
+    }
+
+    // For WSL specifically, check for WSLg availability
+    // WSLg sets WAYLAND_DISPLAY or DISPLAY when available
+    if (platform.type === 'wsl') {
+      // WSLg creates /mnt/wslg directory when GUI support is available
+      if (fs.existsSync('/mnt/wslg')) {
+        return true;
+      }
+    }
+
+    // No desktop environment detected
+    return false;
+  }
+
+  // Unknown platform - assume no desktop available
+  return false;
+}
+
 module.exports = {
   detect,
   isWindows,
@@ -198,5 +289,6 @@ module.exports = {
   getArch,
   getDistro,
   getHomeDir,
-  getTempDir
+  getTempDir,
+  isDesktopAvailable
 };

package/src/utils/ubuntu/apt.js

@@ -32,7 +32,8 @@ async function install(packageName, options = {}) {
   }
 
   const autoConfirm = options.autoConfirm !== false ? '-y' : '';
-  const result = await shell.exec(`sudo apt-get install ${autoConfirm} ${packageName}`);
+  // 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
@@ -55,7 +56,8 @@ async function remove(packageName, options = {}) {
   }
 
   const command = options.purge ? 'purge' : 'remove';
-  const result = await shell.exec(`sudo apt-get ${command} -y ${packageName}`);
+  // 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
@@ -74,7 +76,8 @@ async function update() {
     };
   }
 
-  const result = await shell.exec('sudo apt-get update');
+  // 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
@@ -94,9 +97,10 @@ async function upgrade(packageName) {
     };
   }
 
+  // Use DEBIAN_FRONTEND=noninteractive to avoid prompts during upgrade
   const command = packageName
-    ? `sudo apt-get install -y --only-upgrade ${packageName}`
-    : 'sudo apt-get upgrade -y';
+    ? `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 {
@@ -138,7 +142,8 @@ async function getPackageVersion(packageName) {
 async function addRepository(repo) {
   if (!shell.commandExists('add-apt-repository')) {
     // Try to install software-properties-common first
-    const installResult = await shell.exec('sudo apt-get install -y software-properties-common');
+    // 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,
@@ -275,7 +280,8 @@ async function listInstalled() {
  * @returns {Promise<{ success: boolean, output: string }>}
  */
 async function clean() {
-  const result = await shell.exec('sudo apt-get clean && sudo apt-get autoremove -y');
+  // 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