auto-dev-setup 0.1.0

package/src/platform/macos.js

@@ -0,0 +1,348 @@
+/**
+ * macOS Platform Installer
+ * Handles macOS-specific installations
+ */
+
+const { execCommand, execSilent, commandExists } = require('../utils/executor');
+const logger = require('../utils/logger');
+const ora = require('ora');
+
+/**
+ * Install Xcode Command Line Tools
+ * @returns {Object} Installation result
+ */
+async function installXcodeCliTools() {
+  logger.step('Checking Xcode Command Line Tools...');
+
+  // Check if already installed
+  const check = execSilent('xcode-select -p');
+  if (check.success) {
+    logger.success('Xcode Command Line Tools already installed');
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing Xcode Command Line Tools...');
+  logger.info('This may take several minutes and require user interaction.');
+
+  const result = execCommand('xcode-select --install', { silent: false });
+
+  if (result.success) {
+    logger.success('Xcode Command Line Tools installed');
+    return { success: true, skipped: false };
+  } else {
+    logger.warn('Xcode CLI Tools installation started. Please complete the installation dialog.');
+    logger.info('Run this tool again after installation completes.');
+    return { success: false, skipped: false, pending: true };
+  }
+}
+
+/**
+ * Install Homebrew
+ * @returns {Object} Installation result
+ */
+async function installHomebrew() {
+  logger.step('Checking Homebrew...');
+
+  if (commandExists('brew')) {
+    logger.success('Homebrew already installed');
+
+    // Update Homebrew
+    logger.step('Updating Homebrew...');
+    execCommand('brew update', { silent: true });
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing Homebrew...');
+  const spinner = ora('Downloading and installing Homebrew...').start();
+
+  const installScript =
+    '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"';
+
+  const result = execCommand(installScript);
+
+  if (result.success) {
+    spinner.succeed('Homebrew installed successfully');
+
+    // Add to PATH for Apple Silicon Macs
+    const arch = process.arch;
+    if (arch === 'arm64') {
+      logger.info('Configuring Homebrew for Apple Silicon...');
+      const shellConfig = process.env.SHELL?.includes('zsh')
+        ? '~/.zshrc'
+        : '~/.bash_profile';
+      execCommand(
+        `echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ${shellConfig}`
+      );
+      execCommand('eval "$(/opt/homebrew/bin/brew shellenv)"');
+    }
+
+    return { success: true, skipped: false };
+  } else {
+    spinner.fail('Failed to install Homebrew');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install a package using Homebrew
+ * @param {string} packageName - Package to install
+ * @param {string} caskName - Cask name if it's a cask (optional)
+ * @returns {Object} Installation result
+ */
+async function brewInstall(packageName, caskName = null) {
+  const isCask = caskName !== null;
+  const name = caskName || packageName;
+
+  logger.step(`Checking ${name}...`);
+
+  // Check if already installed
+  if (isCask) {
+    const checkResult = execSilent(`brew list --cask ${name} 2>/dev/null`);
+    if (checkResult.success) {
+      logger.success(`${name} already installed`);
+      return { success: true, skipped: true };
+    }
+  } else {
+    if (commandExists(packageName)) {
+      logger.success(`${name} already installed`);
+      return { success: true, skipped: true };
+    }
+  }
+
+  logger.step(`Installing ${name}...`);
+
+  const command = isCask
+    ? `brew install --cask ${name}`
+    : `brew install ${packageName}`;
+
+  const result = execCommand(command);
+
+  if (result.success) {
+    logger.success(`${name} installed successfully`);
+    return { success: true, skipped: false };
+  } else {
+    logger.error(`Failed to install ${name}`);
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install Git via Homebrew
+ */
+async function installGit() {
+  return brewInstall('git');
+}
+
+/**
+ * Install curl via Homebrew
+ */
+async function installCurl() {
+  return brewInstall('curl');
+}
+
+/**
+ * Install Node.js via Homebrew
+ */
+async function installNode() {
+  return brewInstall('node');
+}
+
+/**
+ * Install Visual Studio Code via Homebrew Cask
+ */
+async function installVSCode() {
+  return brewInstall('visual-studio-code', 'visual-studio-code');
+}
+
+/**
+ * Enable VS Code command line tool
+ */
+async function enableVSCodeCli() {
+  logger.step('Enabling VS Code CLI (code command)...');
+
+  // On macOS, VS Code CLI should be available after cask install
+  // But we can manually add it to PATH if needed
+  if (commandExists('code')) {
+    logger.success('VS Code CLI already available');
+    return { success: true, skipped: true };
+  }
+
+  // Try to create symlink manually
+  const vscodePath =
+    '/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code';
+  const result = execCommand(
+    `ln -sf "${vscodePath}" /usr/local/bin/code 2>/dev/null || sudo ln -sf "${vscodePath}" /usr/local/bin/code`
+  );
+
+  if (result.success || commandExists('code')) {
+    logger.success('VS Code CLI enabled');
+    return { success: true, skipped: false };
+  } else {
+    logger.warn('Could not enable VS Code CLI automatically');
+    logger.info(
+      'You can enable it manually: Open VS Code > Cmd+Shift+P > "Shell Command: Install code"'
+    );
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install Python via Homebrew
+ */
+async function installPython() {
+  // Python is a formula, not a cask
+  logger.step('Checking Python...');
+
+  // Check if python3 is already available
+  if (commandExists('python3')) {
+    logger.success('Python already installed');
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing Python...');
+  const result = execCommand('brew install python');
+
+  if (result.success) {
+    logger.success('Python installed successfully');
+    return { success: true, skipped: false };
+  } else {
+    logger.error('Failed to install Python');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install Java (OpenJDK) via Homebrew
+ */
+async function installJava() {
+  // OpenJDK is a formula, not a cask
+  logger.step('Checking Java...');
+
+  // Check if java is already available
+  if (commandExists('java')) {
+    logger.success('Java already installed');
+
+    // Still configure JAVA_HOME if not set
+    if (!process.env.JAVA_HOME) {
+      await configureJavaHome();
+    }
+
+    return { success: true, skipped: true };
+  }
+
+  logger.step('Installing OpenJDK...');
+  const result = execCommand('brew install openjdk');
+
+  if (result.success) {
+    logger.success('OpenJDK installed successfully');
+
+    // Configure Java
+    await configureJavaHome();
+
+    return { success: true, skipped: false };
+  } else {
+    logger.error('Failed to install OpenJDK');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Configure JAVA_HOME for macOS
+ */
+async function configureJavaHome() {
+  logger.step('Configuring Java...');
+
+  // Create symlink for system Java wrappers
+  execCommand(
+    'sudo ln -sfn $(brew --prefix)/opt/openjdk/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk.jdk 2>/dev/null || true',
+    { silent: true, showCommand: false }
+  );
+
+  // Set JAVA_HOME in shell config
+  const shellConfig = process.env.SHELL?.includes('zsh')
+    ? '~/.zshrc'
+    : '~/.bash_profile';
+
+  // Check if already configured
+  const alreadySet = execSilent(`grep -q 'JAVA_HOME' ${shellConfig} 2>/dev/null`);
+
+  if (!alreadySet.success) {
+    execCommand(
+      `echo 'export JAVA_HOME="$(/usr/libexec/java_home)"' >> ${shellConfig}`,
+      { silent: true, showCommand: false }
+    );
+    execCommand(
+      `echo 'export PATH="$JAVA_HOME/bin:$PATH"' >> ${shellConfig}`,
+      { silent: true, showCommand: false }
+    );
+    logger.success('JAVA_HOME configured');
+  } else {
+    logger.info('JAVA_HOME already configured in shell');
+  }
+}
+
+/**
+ * Run base system setup for macOS
+ */
+async function setupBase() {
+  const results = {
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+
+  // Install Xcode CLI Tools
+  const xcodeResult = await installXcodeCliTools();
+  if (xcodeResult.pending) {
+    return { ...results, pending: true };
+  }
+  if (xcodeResult.success) {
+    (xcodeResult.skipped ? results.skipped : results.installed).push(
+      'Xcode CLI Tools'
+    );
+  } else {
+    results.failed.push('Xcode CLI Tools');
+  }
+
+  // Install Homebrew
+  const brewResult = await installHomebrew();
+  if (brewResult.success) {
+    (brewResult.skipped ? results.skipped : results.installed).push('Homebrew');
+  } else {
+    results.failed.push('Homebrew');
+    return results; // Can't continue without Homebrew
+  }
+
+  // Install Git
+  const gitResult = await installGit();
+  if (gitResult.success) {
+    (gitResult.skipped ? results.skipped : results.installed).push('Git');
+  } else {
+    results.failed.push('Git');
+  }
+
+  // Install curl
+  const curlResult = await installCurl();
+  if (curlResult.success) {
+    (curlResult.skipped ? results.skipped : results.installed).push('curl');
+  } else {
+    results.failed.push('curl');
+  }
+
+  return results;
+}
+
+module.exports = {
+  installXcodeCliTools,
+  installHomebrew,
+  brewInstall,
+  installGit,
+  installCurl,
+  installNode,
+  installVSCode,
+  enableVSCodeCli,
+  installPython,
+  installJava,
+  configureJavaHome,
+  setupBase
+};

package/src/platform/windows.js

@@ -0,0 +1,334 @@
+/**
+ * Windows Platform Installer
+ * Handles Windows-specific installations
+ */
+
+const { execCommand, execSilent, commandExists } = require('../utils/executor');
+const logger = require('../utils/logger');
+const { isElevated } = require('./detector');
+const ora = require('ora');
+
+/**
+ * Check if running with Administrator privileges
+ * @returns {boolean}
+ */
+function checkAdminPrivileges() {
+  return isElevated();
+}
+
+/**
+ * Get the available package manager (winget or choco)
+ * @returns {string|null}
+ */
+function getPackageManager() {
+  if (commandExists('winget')) {
+    return 'winget';
+  }
+  if (commandExists('choco')) {
+    return 'choco';
+  }
+  return null;
+}
+
+/**
+ * Get install command for package manager
+ * @param {string} packageManager - Package manager
+ * @param {string} packageId - Package ID
+ * @returns {string}
+ */
+function getInstallCommand(packageManager, packageId) {
+  if (packageManager === 'winget') {
+    return `winget install --accept-source-agreements --accept-package-agreements -e --id ${packageId}`;
+  }
+  if (packageManager === 'choco') {
+    return `choco install -y ${packageId}`;
+  }
+  return null;
+}
+
+/**
+ * Package name mapping between winget and chocolatey
+ */
+const packageMap = {
+  git: {
+    winget: 'Git.Git',
+    choco: 'git'
+  },
+  nodejs: {
+    winget: 'OpenJS.NodeJS.LTS',
+    choco: 'nodejs-lts'
+  },
+  vscode: {
+    winget: 'Microsoft.VisualStudioCode',
+    choco: 'vscode'
+  },
+  python: {
+    winget: 'Python.Python.3.12',
+    choco: 'python'
+  },
+  java: {
+    winget: 'Microsoft.OpenJDK.17',
+    choco: 'openjdk17'
+  },
+  curl: {
+    winget: 'cURL.cURL',
+    choco: 'curl'
+  }
+};
+
+/**
+ * Get package ID for the package manager
+ * @param {string} packageManager - Package manager
+ * @param {string} genericName - Generic package name
+ * @returns {string}
+ */
+function getPackageId(packageManager, genericName) {
+  return packageMap[genericName]?.[packageManager] || genericName;
+}
+
+/**
+ * Install a package using the available package manager
+ * @param {string} genericName - Generic package name
+ * @param {string} displayName - Display name for logging
+ * @param {string} checkCommand - Command to check if installed
+ * @returns {Object} Installation result
+ */
+async function installPackage(genericName, displayName, checkCommand = null) {
+  const name = displayName || genericName;
+  const packageManager = getPackageManager();
+
+  if (!packageManager) {
+    logger.error('No package manager available (winget or chocolatey required)');
+    return { success: false, skipped: false };
+  }
+
+  logger.step(`Checking ${name}...`);
+
+  // Check if already installed
+  const cmdToCheck = checkCommand || genericName;
+  if (commandExists(cmdToCheck)) {
+    logger.success(`${name} already installed`);
+    return { success: true, skipped: true };
+  }
+
+  const packageId = getPackageId(packageManager, genericName);
+  const command = getInstallCommand(packageManager, packageId);
+
+  logger.step(`Installing ${name} using ${packageManager}...`);
+  const result = execCommand(command);
+
+  if (result.success) {
+    logger.success(`${name} installed successfully`);
+    return { success: true, skipped: false };
+  } else {
+    logger.error(`Failed to install ${name}`);
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install Chocolatey package manager
+ * @returns {Object} Installation result
+ */
+async function installChocolatey() {
+  logger.step('Checking Chocolatey...');
+
+  if (commandExists('choco')) {
+    logger.success('Chocolatey already installed');
+    return { success: true, skipped: true };
+  }
+
+  if (!checkAdminPrivileges()) {
+    logger.error('Administrator privileges required to install Chocolatey');
+    logger.info('Please run this tool as Administrator');
+    return { success: false, skipped: false, needsAdmin: true };
+  }
+
+  logger.step('Installing Chocolatey...');
+
+  const installScript = `
+    Set-ExecutionPolicy Bypass -Scope Process -Force;
+    [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;
+    iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
+  `;
+
+  const result = execCommand(`powershell -Command "${installScript.replace(/\n/g, ' ')}"`);
+
+  if (result.success) {
+    logger.success('Chocolatey installed successfully');
+    return { success: true, skipped: false };
+  } else {
+    logger.error('Failed to install Chocolatey');
+    return { success: false, skipped: false };
+  }
+}
+
+/**
+ * Install Git
+ */
+async function installGit() {
+  return installPackage('git', 'Git', 'git');
+}
+
+/**
+ * Install curl
+ */
+async function installCurl() {
+  // curl is included in Windows 10+ by default
+  if (commandExists('curl')) {
+    logger.success('curl already available (built into Windows)');
+    return { success: true, skipped: true };
+  }
+  return installPackage('curl', 'curl', 'curl');
+}
+
+/**
+ * Install Node.js
+ */
+async function installNode() {
+  return installPackage('nodejs', 'Node.js LTS', 'node');
+}
+
+/**
+ * Install Visual Studio Code
+ */
+async function installVSCode() {
+  return installPackage('vscode', 'Visual Studio Code', 'code');
+}
+
+/**
+ * Enable VS Code CLI
+ */
+async function enableVSCodeCli() {
+  logger.step('Checking VS Code CLI...');
+
+  if (commandExists('code')) {
+    logger.success('VS Code CLI already available');
+    return { success: true, skipped: true };
+  }
+
+  // VS Code installer usually adds to PATH, but may need a terminal restart
+  logger.warn('VS Code CLI may require terminal restart to be available');
+  return { success: true, skipped: true };
+}
+
+/**
+ * Install Python
+ */
+async function installPython() {
+  return installPackage('python', 'Python', 'python');
+}
+
+/**
+ * Install Java (OpenJDK)
+ */
+async function installJava() {
+  const result = await installPackage('java', 'OpenJDK 17', 'java');
+
+  if (result.success && !result.skipped) {
+    // Set JAVA_HOME
+    logger.step('Configuring JAVA_HOME...');
+
+    const javaHome = execSilent('where java');
+    if (javaHome.success && javaHome.output) {
+      const javaPath = javaHome.output.split('\n')[0].trim();
+      const javaBinDir = javaPath.replace('\\bin\\java.exe', '');
+
+      // Set user environment variable
+      execCommand(
+        `setx JAVA_HOME "${javaBinDir}"`,
+        { silent: true }
+      );
+      logger.success('JAVA_HOME configured');
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Check PowerShell availability
+ */
+function checkPowerShell() {
+  return commandExists('powershell') || commandExists('pwsh');
+}
+
+/**
+ * Run base system setup for Windows
+ */
+async function setupBase() {
+  const results = {
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+
+  // Check PowerShell
+  if (!checkPowerShell()) {
+    logger.error('PowerShell is required but not found');
+    results.failed.push('PowerShell');
+    return results;
+  }
+  results.skipped.push('PowerShell');
+
+  // Check admin privileges
+  if (!checkAdminPrivileges()) {
+    logger.warn('Not running as Administrator');
+    logger.info('Some installations may fail. Consider running as Administrator.');
+  }
+
+  // Check/install package manager
+  let packageManager = getPackageManager();
+
+  if (!packageManager) {
+    logger.info('No package manager found. Installing Chocolatey...');
+    const chocoResult = await installChocolatey();
+    if (chocoResult.success) {
+      results.installed.push('Chocolatey');
+      packageManager = 'choco';
+    } else {
+      results.failed.push('Chocolatey');
+      logger.error('Cannot continue without a package manager');
+      return results;
+    }
+  } else {
+    logger.success(`Using package manager: ${packageManager}`);
+    results.skipped.push(packageManager === 'winget' ? 'winget' : 'Chocolatey');
+  }
+
+  // Install Git
+  const gitResult = await installGit();
+  if (gitResult.success) {
+    (gitResult.skipped ? results.skipped : results.installed).push('Git');
+  } else {
+    results.failed.push('Git');
+  }
+
+  // Install/check curl
+  const curlResult = await installCurl();
+  if (curlResult.success) {
+    (curlResult.skipped ? results.skipped : results.installed).push('curl');
+  } else {
+    results.failed.push('curl');
+  }
+
+  return results;
+}
+
+module.exports = {
+  checkAdminPrivileges,
+  getPackageManager,
+  getInstallCommand,
+  getPackageId,
+  installPackage,
+  installChocolatey,
+  installGit,
+  installCurl,
+  installNode,
+  installVSCode,
+  enableVSCodeCli,
+  installPython,
+  installJava,
+  checkPowerShell,
+  setupBase
+};