@fredlackey/devutils 0.0.1

package/src/utils/windows/registry.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+/**
+ * Windows Registry Access Utilities
+ *
+ * Windows-specific utilities for reading the Windows registry.
+ * Used for detecting installed applications and their properties.
+ */
+
+const shell = require('../common/shell');
+
+/**
+ * Common registry paths for installed applications
+ */
+const UNINSTALL_PATHS = [
+  'HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
+  'HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
+  'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall'
+];
+
+/**
+ * Checks Windows registry uninstall keys for an application
+ * @param {string} appName - The application name to check
+ * @returns {Promise<boolean>}
+ */
+async function isAppInstalled(appName) {
+  const appInfo = await findAppInRegistry(appName);
+  return appInfo !== null;
+}
+
+/**
+ * Retrieves installation path from registry
+ * @param {string} appName - The application name
+ * @returns {Promise<string|null>}
+ */
+async function getInstallPath(appName) {
+  const appInfo = await findAppInRegistry(appName);
+  return appInfo ? appInfo.installLocation : null;
+}
+
+/**
+ * Retrieves version from registry
+ * @param {string} appName - The application name
+ * @returns {Promise<string|null>}
+ */
+async function getAppVersion(appName) {
+  const appInfo = await findAppInRegistry(appName);
+  return appInfo ? appInfo.version : null;
+}
+
+/**
+ * Finds an application in the registry and returns its info
+ * @param {string} appName - The application name to find
+ * @returns {Promise<{ displayName: string, version: string, installLocation: string, publisher: string }|null>}
+ */
+async function findAppInRegistry(appName) {
+  const normalizedName = appName.toLowerCase();
+
+  for (const basePath of UNINSTALL_PATHS) {
+    // List all subkeys
+    const listResult = await shell.exec(
+      `reg query "${basePath}" 2>nul`
+    );
+
+    if (listResult.code !== 0) {
+      continue;
+    }
+
+    const subkeys = listResult.stdout
+      .split('\n')
+      .filter((line) => line.trim().startsWith(basePath))
+      .map((line) => line.trim());
+
+    for (const subkey of subkeys) {
+      const displayName = await getValue(subkey, 'DisplayName');
+      if (!displayName) continue;
+
+      // Check if this is the app we're looking for
+      if (displayName.toLowerCase().includes(normalizedName)) {
+        return {
+          displayName,
+          version: await getValue(subkey, 'DisplayVersion'),
+          installLocation: await getValue(subkey, 'InstallLocation'),
+          publisher: await getValue(subkey, 'Publisher')
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Checks if a registry key exists
+ * @param {string} keyPath - The full registry key path
+ * @returns {Promise<boolean>}
+ */
+async function keyExists(keyPath) {
+  const result = await shell.exec(`reg query "${keyPath}" 2>nul`);
+  return result.code === 0;
+}
+
+/**
+ * Reads a value from the registry
+ * @param {string} keyPath - The full registry key path
+ * @param {string} valueName - The value name to read
+ * @returns {Promise<string|null>}
+ */
+async function getValue(keyPath, valueName) {
+  const result = await shell.exec(
+    `reg query "${keyPath}" /v "${valueName}" 2>nul`
+  );
+
+  if (result.code !== 0) {
+    return null;
+  }
+
+  // Parse the output
+  // Format: "    ValueName    REG_SZ    Value"
+  const lines = result.stdout.split('\n');
+  for (const line of lines) {
+    if (line.includes(valueName)) {
+      // Split by registry type (REG_SZ, REG_DWORD, etc.)
+      const match = line.match(/REG_\w+\s+(.+)$/);
+      if (match) {
+        return match[1].trim();
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Lists all values in a registry key
+ * @param {string} keyPath - The full registry key path
+ * @returns {Promise<Array<{ name: string, type: string, value: string }>>}
+ */
+async function listValues(keyPath) {
+  const result = await shell.exec(`reg query "${keyPath}" 2>nul`);
+
+  if (result.code !== 0) {
+    return [];
+  }
+
+  const values = [];
+  const lines = result.stdout.split('\n');
+
+  for (const line of lines) {
+    // Skip empty lines and the key path line
+    if (!line.trim() || line.trim().startsWith('HK')) {
+      continue;
+    }
+
+    // Parse "    Name    REG_TYPE    Value"
+    const match = line.match(/^\s+(\S+)\s+(REG_\w+)\s+(.*)$/);
+    if (match) {
+      values.push({
+        name: match[1],
+        type: match[2],
+        value: match[3].trim()
+      });
+    }
+  }
+
+  return values;
+}
+
+/**
+ * Lists all subkeys of a registry key
+ * @param {string} keyPath - The full registry key path
+ * @returns {Promise<string[]>}
+ */
+async function listSubkeys(keyPath) {
+  const result = await shell.exec(`reg query "${keyPath}" 2>nul`);
+
+  if (result.code !== 0) {
+    return [];
+  }
+
+  return result.stdout
+    .split('\n')
+    .filter((line) => line.trim().startsWith('HK'))
+    .map((line) => line.trim())
+    .filter((line) => line !== keyPath);
+}
+
+/**
+ * Gets all installed applications from the registry
+ * @returns {Promise<Array<{ name: string, version: string, publisher: string, installLocation: string }>>}
+ */
+async function listInstalledApps() {
+  const apps = [];
+
+  for (const basePath of UNINSTALL_PATHS) {
+    const subkeys = await listSubkeys(basePath);
+
+    for (const subkey of subkeys) {
+      const displayName = await getValue(subkey, 'DisplayName');
+      if (!displayName) continue;
+
+      // Skip system components and updates
+      const systemComponent = await getValue(subkey, 'SystemComponent');
+      if (systemComponent === '1') continue;
+
+      apps.push({
+        name: displayName,
+        version: await getValue(subkey, 'DisplayVersion') || '',
+        publisher: await getValue(subkey, 'Publisher') || '',
+        installLocation: await getValue(subkey, 'InstallLocation') || ''
+      });
+    }
+  }
+
+  // Remove duplicates by name
+  const seen = new Set();
+  return apps.filter((app) => {
+    if (seen.has(app.name)) {
+      return false;
+    }
+    seen.add(app.name);
+    return true;
+  });
+}
+
+/**
+ * Gets the uninstall command for an application
+ * @param {string} appName - The application name
+ * @returns {Promise<string|null>}
+ */
+async function getUninstallCommand(appName) {
+  const normalizedName = appName.toLowerCase();
+
+  for (const basePath of UNINSTALL_PATHS) {
+    const subkeys = await listSubkeys(basePath);
+
+    for (const subkey of subkeys) {
+      const displayName = await getValue(subkey, 'DisplayName');
+      if (!displayName) continue;
+
+      if (displayName.toLowerCase().includes(normalizedName)) {
+        // Try QuietUninstallString first (silent uninstall)
+        const quietUninstall = await getValue(subkey, 'QuietUninstallString');
+        if (quietUninstall) {
+          return quietUninstall;
+        }
+
+        // Fall back to UninstallString
+        const uninstall = await getValue(subkey, 'UninstallString');
+        return uninstall;
+      }
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  isAppInstalled,
+  getInstallPath,
+  getAppVersion,
+  findAppInRegistry,
+  keyExists,
+  getValue,
+  listValues,
+  listSubkeys,
+  listInstalledApps,
+  getUninstallCommand
+};

package/src/utils/windows/shell.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+/**
+ * Windows Shell Environment Detection Utilities
+ *
+ * Windows-specific utilities for detecting the shell environment.
+ * These functions address a Windows-specific concern: CMD and PowerShell have
+ * fundamentally different syntax and capabilities. Unix shells (bash, zsh, sh)
+ * are interchangeable for command execution purposes.
+ */
+
+const shell = require('../common/shell');
+
+/**
+ * Checks if running inside PowerShell
+ * @returns {boolean}
+ */
+function isPowerShell() {
+  // Check for PowerShell-specific environment variables
+  if (process.env.PSModulePath) {
+    return true;
+  }
+
+  // Check if the parent process is PowerShell
+  if (process.env.SHELL && process.env.SHELL.includes('pwsh')) {
+    return true;
+  }
+
+  // Check ComSpec for PowerShell
+  const comspec = process.env.ComSpec || '';
+  if (comspec.toLowerCase().includes('powershell')) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if running inside CMD
+ * @returns {boolean}
+ */
+function isCmd() {
+  // If we're in PowerShell, we're not in CMD
+  if (isPowerShell()) {
+    return false;
+  }
+
+  // Check ComSpec for cmd.exe
+  const comspec = process.env.ComSpec || '';
+  if (comspec.toLowerCase().includes('cmd.exe')) {
+    return true;
+  }
+
+  // Check PROMPT environment variable (CMD-specific)
+  if (process.env.PROMPT) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Checks if running inside Windows Terminal
+ * @returns {boolean}
+ */
+function isWindowsTerminal() {
+  // Windows Terminal sets WT_SESSION
+  return !!process.env.WT_SESSION;
+}
+
+/**
+ * Returns PowerShell version (5.x for Windows PowerShell, 7.x for PowerShell Core)
+ * @returns {Promise<string|null>}
+ */
+async function getPowerShellVersion() {
+  // Try pwsh first (PowerShell Core / 7.x)
+  if (shell.commandExists('pwsh')) {
+    const result = await shell.exec('pwsh -NoProfile -Command "$PSVersionTable.PSVersion.ToString()"');
+    if (result.code === 0 && result.stdout.trim()) {
+      return result.stdout.trim();
+    }
+  }
+
+  // Try powershell (Windows PowerShell / 5.x)
+  if (shell.commandExists('powershell')) {
+    const result = await shell.exec('powershell -NoProfile -Command "$PSVersionTable.PSVersion.ToString()"');
+    if (result.code === 0 && result.stdout.trim()) {
+      return result.stdout.trim();
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Returns the current shell name
+ * @returns {'powershell'|'pwsh'|'cmd'|'unknown'}
+ */
+function getShellName() {
+  if (shell.commandExists('pwsh') && isPowerShell()) {
+    // Check if it's specifically pwsh (Core) vs powershell (Windows)
+    const psModulePath = process.env.PSModulePath || '';
+    if (psModulePath.includes('PowerShell\\7') || psModulePath.includes('powershell/7')) {
+      return 'pwsh';
+    }
+    return 'powershell';
+  }
+
+  if (isPowerShell()) {
+    return 'powershell';
+  }
+
+  if (isCmd()) {
+    return 'cmd';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Checks if PowerShell Core (pwsh 7.x) is available
+ * @returns {boolean}
+ */
+function hasPowerShellCore() {
+  return shell.commandExists('pwsh');
+}
+
+/**
+ * Checks if Windows PowerShell (5.x) is available
+ * @returns {boolean}
+ */
+function hasWindowsPowerShell() {
+  return shell.commandExists('powershell');
+}
+
+/**
+ * Gets the path to the preferred PowerShell executable
+ * @returns {string|null}
+ */
+function getPowerShellPath() {
+  // Prefer PowerShell Core if available
+  const pwshPath = shell.which('pwsh');
+  if (pwshPath) {
+    return pwshPath;
+  }
+
+  // Fall back to Windows PowerShell
+  const powershellPath = shell.which('powershell');
+  return powershellPath;
+}
+
+/**
+ * Executes a PowerShell command
+ * @param {string} command - The PowerShell command to execute
+ * @param {Object} [options] - Execution options
+ * @param {boolean} [options.noProfile=true] - Don't load the PowerShell profile
+ * @param {boolean} [options.usePwsh=true] - Prefer pwsh over powershell
+ * @returns {Promise<{ success: boolean, stdout: string, stderr: string }>}
+ */
+async function execPowerShell(command, options = {}) {
+  const noProfile = options.noProfile !== false ? '-NoProfile' : '';
+  const usePwsh = options.usePwsh !== false && hasPowerShellCore();
+
+  const ps = usePwsh ? 'pwsh' : 'powershell';
+
+  // Escape double quotes in the command
+  const escapedCommand = command.replace(/"/g, '\\"');
+
+  const result = await shell.exec(`${ps} ${noProfile} -Command "${escapedCommand}"`);
+  return {
+    success: result.code === 0,
+    stdout: result.stdout,
+    stderr: result.stderr
+  };
+}
+
+/**
+ * Gets the Windows build number
+ * @returns {Promise<number|null>}
+ */
+async function getWindowsBuild() {
+  const result = await shell.exec('powershell -NoProfile -Command "[System.Environment]::OSVersion.Version.Build"');
+  if (result.code === 0 && result.stdout.trim()) {
+    const build = parseInt(result.stdout.trim(), 10);
+    return isNaN(build) ? null : build;
+  }
+  return null;
+}
+
+/**
+ * Gets the Windows version name (e.g., "Windows 11", "Windows 10")
+ * @returns {Promise<string|null>}
+ */
+async function getWindowsVersion() {
+  const result = await shell.exec('powershell -NoProfile -Command "(Get-WmiObject Win32_OperatingSystem).Caption"');
+  if (result.code === 0 && result.stdout.trim()) {
+    return result.stdout.trim();
+  }
+  return null;
+}
+
+/**
+ * Checks if the current console supports ANSI colors
+ * @returns {boolean}
+ */
+function supportsAnsiColors() {
+  // Windows Terminal always supports ANSI
+  if (isWindowsTerminal()) {
+    return true;
+  }
+
+  // Check for ANSICON (adds ANSI support to CMD)
+  if (process.env.ANSICON) {
+    return true;
+  }
+
+  // Check for ConEmu
+  if (process.env.ConEmuANSI === 'ON') {
+    return true;
+  }
+
+  // Modern Windows 10+ CMD supports ANSI if virtual terminal processing is enabled
+  // This is hard to detect without trying, so we assume modern Windows supports it
+  return true;
+}
+
+module.exports = {
+  isPowerShell,
+  isCmd,
+  isWindowsTerminal,
+  getPowerShellVersion,
+  getShellName,
+  hasPowerShellCore,
+  hasWindowsPowerShell,
+  getPowerShellPath,
+  execPowerShell,
+  getWindowsBuild,
+  getWindowsVersion,
+  supportsAnsiColors
+};