@fredlackey/devutils 0.0.18 → 0.1.0

package/src/utils/windows/choco.js

@@ -1,465 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Chocolatey Package Manager Utilities
- *
- * Windows-specific utilities for interacting with Chocolatey.
- */
-
-const shell = require('../common/shell');
-const fs = require('fs');
-
-/**
- * Well-known path where Chocolatey is typically installed on Windows.
- * This path is used as a fallback when choco is not found in PATH,
- * which can happen when Chocolatey was just installed and the current
- * process still has the old PATH environment variable.
- */
-const CHOCO_KNOWN_PATH = 'C:\\ProgramData\\chocolatey\\bin\\choco.exe';
-
-/**
- * Well-known directory where Chocolatey installs command binaries.
- * All Chocolatey-installed commands get shims placed here.
- */
-const CHOCO_BIN_DIR = 'C:\\ProgramData\\chocolatey\\bin';
-
-/**
- * Adds Chocolatey's bin directory to the current process's PATH.
- *
- * This is necessary after installing Chocolatey because the PATH environment
- * variable in the current Node.js process won't be updated until a new terminal
- * is opened. By manually adding the bin directory, subsequent child processes
- * spawned by this process will be able to find Chocolatey-installed commands.
- *
- * This function is idempotent - it won't add the path if it's already present.
- *
- * @returns {boolean} True if PATH was modified, false if already present
- */
-function addBinToPath() {
-  const currentPath = process.env.PATH || '';
-  const pathSeparator = ';';
-
-  // Check if already in PATH (case-insensitive on Windows)
-  const paths = currentPath.split(pathSeparator);
-  const alreadyInPath = paths.some(p =>
-    p.toLowerCase() === CHOCO_BIN_DIR.toLowerCase()
-  );
-
-  if (alreadyInPath) {
-    return false;
-  }
-
-  // Prepend Chocolatey bin directory to PATH
-  process.env.PATH = `${CHOCO_BIN_DIR}${pathSeparator}${currentPath}`;
-  return true;
-}
-
-/**
- * Checks if Chocolatey is installed.
- *
- * First checks PATH, then falls back to checking the well-known
- * installation path. This handles the case where Chocolatey was just
- * installed and PATH hasn't been updated in the current process.
- *
- * @returns {boolean}
- */
-function isInstalled() {
-  return getExecutablePath() !== null;
-}
-
-/**
- * Gets the path to the Chocolatey executable.
- *
- * First checks if choco is in PATH, then falls back to the well-known
- * installation path. This handles the case where Chocolatey was just
- * installed and PATH hasn't been updated in the current process.
- *
- * @returns {string|null} The path to choco executable, or null if not found
- */
-function getExecutablePath() {
-  // First check if choco is in PATH
-  if (shell.commandExists('choco')) {
-    return 'choco';
-  }
-
-  // Fall back to checking the well-known installation path
-  // This handles cases where Chocolatey was just installed and PATH
-  // hasn't been updated in the current Node.js process
-  try {
-    if (fs.existsSync(CHOCO_KNOWN_PATH)) {
-      return CHOCO_KNOWN_PATH;
-    }
-  } catch {
-    // Ignore errors checking the path
-  }
-
-  return null;
-}
-
-/**
- * Checks if a command binary exists in Chocolatey's bin directory.
- *
- * This is useful for verifying installations when the PATH hasn't been
- * updated yet. Chocolatey creates shims (small .exe files) in its bin
- * directory for all installed commands.
- *
- * @param {string} commandName - The command name (without .exe extension)
- * @returns {boolean} True if the binary exists in Chocolatey's bin directory
- */
-function commandBinaryExists(commandName) {
-  const path = require('path');
-  const binaryPath = path.join(CHOCO_BIN_DIR, `${commandName}.exe`);
-
-  try {
-    return fs.existsSync(binaryPath);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Gets the full path to a command's binary in Chocolatey's bin directory.
- *
- * @param {string} commandName - The command name (without .exe extension)
- * @returns {string|null} Full path to the binary, or null if not found
- */
-function getCommandBinaryPath(commandName) {
-  const path = require('path');
-  const binaryPath = path.join(CHOCO_BIN_DIR, `${commandName}.exe`);
-
-  try {
-    if (fs.existsSync(binaryPath)) {
-      return binaryPath;
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  return null;
-}
-
-/**
- * Returns the installed Chocolatey version
- * @returns {Promise<string|null>}
- */
-async function getVersion() {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return null;
-  }
-
-  const result = await shell.exec(`"${chocoPath}" --version`);
-  if (result.code === 0) {
-    return result.stdout.trim();
-  }
-  return null;
-}
-
-/**
- * Installs a Chocolatey package
- * @param {string} packageName - The package name to install
- * @param {Object} [options] - Installation options
- * @param {boolean} [options.force=false] - Force reinstall if already installed
- * @param {string} [options.version] - Specific version to install
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function install(packageName, options = {}) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return {
-      success: false,
-      output: 'Chocolatey is not installed'
-    };
-  }
-
-  let command = `"${chocoPath}" install ${packageName} -y`;
-
-  if (options.force) {
-    command += ' --force';
-  }
-
-  if (options.version) {
-    command += ` --version=${options.version}`;
-  }
-
-  const result = await shell.exec(command);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Removes a Chocolatey package
- * @param {string} packageName - The package name to remove
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function uninstall(packageName) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return {
-      success: false,
-      output: 'Chocolatey is not installed'
-    };
-  }
-
-  const result = await shell.exec(`"${chocoPath}" uninstall ${packageName} -y`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Checks if a package is installed via Chocolatey
- * @param {string} packageName - The package name to check
- * @returns {Promise<boolean>}
- */
-async function isPackageInstalled(packageName) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return false;
-  }
-
-  const result = await shell.exec(`"${chocoPath}" list --local-only --exact ${packageName}`);
-  // Output contains the package name if installed
-  return result.code === 0 && result.stdout.toLowerCase().includes(packageName.toLowerCase());
-}
-
-/**
- * Returns the installed version of a package
- * @param {string} packageName - The package name
- * @returns {Promise<string|null>}
- */
-async function getPackageVersion(packageName) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return null;
-  }
-
-  const result = await shell.exec(`"${chocoPath}" list --local-only --exact ${packageName}`);
-  if (result.code !== 0) {
-    return null;
-  }
-
-  // Output format: "packageName version"
-  const lines = result.stdout.split('\n').filter(Boolean);
-  for (const line of lines) {
-    const parts = line.trim().split(/\s+/);
-    if (parts[0] && parts[0].toLowerCase() === packageName.toLowerCase()) {
-      return parts[1] || null;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Upgrades a package or all packages
- * @param {string} [packageName] - The package to upgrade (all if omitted)
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function upgrade(packageName) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return {
-      success: false,
-      output: 'Chocolatey is not installed'
-    };
-  }
-
-  const target = packageName || 'all';
-  const result = await shell.exec(`"${chocoPath}" upgrade ${target} -y`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Searches the Chocolatey repository
- * @param {string} query - The search query
- * @returns {Promise<Array<{ name: string, version: string }>>}
- */
-async function search(query) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return [];
-  }
-
-  const result = await shell.exec(`"${chocoPath}" search "${query}"`);
-  if (result.code !== 0) {
-    return [];
-  }
-
-  const packages = [];
-  const lines = result.stdout.split('\n').filter(Boolean);
-
-  for (const line of lines) {
-    // Skip header and summary lines
-    if (line.includes('packages found') || line.includes('Chocolatey')) {
-      continue;
-    }
-
-    const parts = line.trim().split(/\s+/);
-    if (parts.length >= 2 && !parts[0].includes('=')) {
-      packages.push({
-        name: parts[0],
-        version: parts[1]
-      });
-    }
-  }
-
-  return packages;
-}
-
-/**
- * Gets information about a package
- * @param {string} packageName - The package name
- * @returns {Promise<string|null>}
- */
-async function info(packageName) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return null;
-  }
-
-  const result = await shell.exec(`"${chocoPath}" info ${packageName}`);
-  if (result.code === 0) {
-    return result.stdout;
-  }
-  return null;
-}
-
-/**
- * Lists all locally installed packages
- * @returns {Promise<Array<{ name: string, version: string }>>}
- */
-async function listInstalled() {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return [];
-  }
-
-  const result = await shell.exec(`"${chocoPath}" list --local-only`);
-  if (result.code !== 0) {
-    return [];
-  }
-
-  const packages = [];
-  const lines = result.stdout.split('\n').filter(Boolean);
-
-  for (const line of lines) {
-    // Skip summary line
-    if (line.includes('packages installed')) {
-      continue;
-    }
-
-    const parts = line.trim().split(/\s+/);
-    if (parts.length >= 2) {
-      packages.push({
-        name: parts[0],
-        version: parts[1]
-      });
-    }
-  }
-
-  return packages;
-}
-
-/**
- * Lists outdated packages
- * @returns {Promise<Array<{ name: string, currentVersion: string, availableVersion: string }>>}
- */
-async function listOutdated() {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return [];
-  }
-
-  const result = await shell.exec(`"${chocoPath}" outdated`);
-  if (result.code !== 0) {
-    return [];
-  }
-
-  const packages = [];
-  const lines = result.stdout.split('\n').filter(Boolean);
-
-  for (const line of lines) {
-    // Lines with outdated packages have format: "name|currentVer|availableVer|pinned"
-    if (line.includes('|')) {
-      const parts = line.split('|');
-      if (parts.length >= 3) {
-        packages.push({
-          name: parts[0].trim(),
-          currentVersion: parts[1].trim(),
-          availableVersion: parts[2].trim()
-        });
-      }
-    }
-  }
-
-  return packages;
-}
-
-/**
- * Pins a package to prevent upgrades
- * @param {string} packageName - The package name
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function pin(packageName) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return {
-      success: false,
-      output: 'Chocolatey is not installed'
-    };
-  }
-
-  const result = await shell.exec(`"${chocoPath}" pin add -n="${packageName}"`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-/**
- * Unpins a package to allow upgrades
- * @param {string} packageName - The package name
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function unpin(packageName) {
-  const chocoPath = getExecutablePath();
-  if (!chocoPath) {
-    return {
-      success: false,
-      output: 'Chocolatey is not installed'
-    };
-  }
-
-  const result = await shell.exec(`"${chocoPath}" pin remove -n="${packageName}"`);
-  return {
-    success: result.code === 0,
-    output: result.stdout || result.stderr
-  };
-}
-
-module.exports = {
-  isInstalled,
-  getExecutablePath,
-  addBinToPath,
-  commandBinaryExists,
-  getCommandBinaryPath,
-  getVersion,
-  install,
-  uninstall,
-  isPackageInstalled,
-  getPackageVersion,
-  upgrade,
-  search,
-  info,
-  listInstalled,
-  listOutdated,
-  pin,
-  unpin
-};

package/src/utils/windows/env.js

@@ -1,246 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Windows Environment Variables Utilities
- *
- * Windows-specific utilities for managing environment variables.
- */
-
-const shell = require('../common/shell');
-const path = require('path');
-
-/**
- * Returns the system PATH as an array
- * @returns {string[]}
- */
-function getPath() {
-  const pathEnv = process.env.PATH || process.env.Path || '';
-  return pathEnv.split(';').filter(Boolean);
-}
-
-/**
- * Adds a directory to the user PATH
- * Note: Changes take effect in new processes, not the current one
- * @param {string} directory - The directory to add to PATH
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function addToPath(directory) {
-  // Normalize the path
-  const normalizedDir = path.resolve(directory);
-
-  // Check if already in PATH
-  const currentPath = getPath();
-  if (currentPath.some((p) => path.resolve(p).toLowerCase() === normalizedDir.toLowerCase())) {
-    return {
-      success: true,
-      output: 'Directory is already in PATH'
-    };
-  }
-
-  // Use PowerShell to modify user PATH
-  const command = `
-    $currentPath = [Environment]::GetEnvironmentVariable('Path', 'User')
-    $newPath = "$currentPath;${normalizedDir}"
-    [Environment]::SetEnvironmentVariable('Path', $newPath, 'User')
-  `.replace(/\n/g, ' ');
-
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-  return {
-    success: result.code === 0,
-    output: result.code === 0
-      ? `Added ${normalizedDir} to user PATH. Restart your terminal for changes to take effect.`
-      : result.stderr
-  };
-}
-
-/**
- * Removes a directory from the user PATH
- * @param {string} directory - The directory to remove from PATH
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function removeFromPath(directory) {
-  const normalizedDir = path.resolve(directory);
-
-  // Use PowerShell to modify user PATH
-  const command = `
-    $currentPath = [Environment]::GetEnvironmentVariable('Path', 'User')
-    $paths = $currentPath -split ';' | Where-Object { $_.Trim() -ne '' -and [System.IO.Path]::GetFullPath($_).ToLower() -ne '${normalizedDir.toLowerCase().replace(/\\/g, '\\\\')}' }
-    $newPath = $paths -join ';'
-    [Environment]::SetEnvironmentVariable('Path', $newPath, 'User')
-  `.replace(/\n/g, ' ');
-
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-  return {
-    success: result.code === 0,
-    output: result.code === 0
-      ? `Removed ${normalizedDir} from user PATH. Restart your terminal for changes to take effect.`
-      : result.stderr
-  };
-}
-
-/**
- * Gets an environment variable value
- * @param {string} varName - The variable name
- * @param {'User'|'Machine'|'Process'} [scope='Process'] - The scope to check
- * @returns {Promise<string|null>}
- */
-async function get(varName, scope = 'Process') {
-  if (scope === 'Process') {
-    return process.env[varName] || null;
-  }
-
-  const command = `[Environment]::GetEnvironmentVariable('${varName}', '${scope}')`;
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-
-  if (result.code === 0 && result.stdout.trim()) {
-    return result.stdout.trim();
-  }
-  return null;
-}
-
-/**
- * Sets a user environment variable
- * @param {string} varName - The variable name
- * @param {string} value - The value to set
- * @param {'User'|'Machine'} [scope='User'] - The scope (Machine requires admin)
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function set(varName, value, scope = 'User') {
-  const command = `[Environment]::SetEnvironmentVariable('${varName}', '${value}', '${scope}')`;
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-
-  return {
-    success: result.code === 0,
-    output: result.code === 0
-      ? `Set ${varName}=${value} in ${scope} scope. Restart your terminal for changes to take effect.`
-      : result.stderr
-  };
-}
-
-/**
- * Removes a user environment variable
- * @param {string} varName - The variable name
- * @param {'User'|'Machine'} [scope='User'] - The scope
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function remove(varName, scope = 'User') {
-  const command = `[Environment]::SetEnvironmentVariable('${varName}', $null, '${scope}')`;
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-
-  return {
-    success: result.code === 0,
-    output: result.code === 0
-      ? `Removed ${varName} from ${scope} scope. Restart your terminal for changes to take effect.`
-      : result.stderr
-  };
-}
-
-/**
- * Gets all user environment variables
- * @returns {Promise<Object<string, string>>}
- */
-async function getUserVariables() {
-  const command = '[Environment]::GetEnvironmentVariables("User") | ConvertTo-Json';
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-
-  if (result.code === 0 && result.stdout.trim()) {
-    try {
-      return JSON.parse(result.stdout);
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-
-/**
- * Gets all machine (system) environment variables
- * @returns {Promise<Object<string, string>>}
- */
-async function getMachineVariables() {
-  const command = '[Environment]::GetEnvironmentVariables("Machine") | ConvertTo-Json';
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-
-  if (result.code === 0 && result.stdout.trim()) {
-    try {
-      return JSON.parse(result.stdout);
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-
-/**
- * Expands environment variables in a string
- * @param {string} str - The string containing variables like %VAR%
- * @returns {string}
- */
-function expand(str) {
-  return str.replace(/%([^%]+)%/g, (_, varName) => {
-    return process.env[varName] || `%${varName}%`;
-  });
-}
-
-/**
- * Broadcasts a WM_SETTINGCHANGE message to notify other applications
- * of environment variable changes
- * @returns {Promise<{ success: boolean, output: string }>}
- */
-async function broadcastChange() {
-  const command = `
-    Add-Type -TypeDefinition @"
-    using System;
-    using System.Runtime.InteropServices;
-    public class Win32 {
-        [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
-        public static extern IntPtr SendMessageTimeout(
-            IntPtr hWnd, uint Msg, UIntPtr wParam, string lParam,
-            uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);
-    }
-"@
-    $HWND_BROADCAST = [IntPtr]0xffff
-    $WM_SETTINGCHANGE = 0x1a
-    $result = [UIntPtr]::Zero
-    [Win32]::SendMessageTimeout($HWND_BROADCAST, $WM_SETTINGCHANGE, [UIntPtr]::Zero, "Environment", 2, 5000, [ref]$result)
-  `.replace(/\n/g, ' ');
-
-  const result = await shell.exec(`powershell -NoProfile -Command "${command}"`);
-  return {
-    success: result.code === 0,
-    output: result.code === 0
-      ? 'Broadcasted environment change notification'
-      : result.stderr
-  };
-}
-
-/**
- * Refreshes the current process's environment from the registry
- * Note: This only affects the current Node.js process
- * @returns {Promise<void>}
- */
-async function refresh() {
-  // Get updated PATH from both User and Machine scopes
-  const userPath = await get('Path', 'User');
-  const machinePath = await get('Path', 'Machine');
-
-  if (userPath || machinePath) {
-    const combined = [machinePath, userPath].filter(Boolean).join(';');
-    process.env.PATH = combined;
-    process.env.Path = combined;
-  }
-}
-
-module.exports = {
-  getPath,
-  addToPath,
-  removeFromPath,
-  get,
-  set,
-  remove,
-  getUserVariables,
-  getMachineVariables,
-  expand,
-  broadcastChange,
-  refresh
-};