imcp 0.1.7 → 0.1.8-dev

package/src/utils/osUtils.ts

@@ -1,700 +0,0 @@
-import { OSType } from '../core/metadatas/types.js';
-import os from 'os';
-import { exec } from 'child_process';
-import util from 'util';
-import { Logger } from './logger.js';
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import * as fsSync from 'fs';
-
-const execAsync = util.promisify(exec);
-
-export function getOSType(): OSType {
-  const platform = os.platform();
-  Logger.debug({
-    action: 'get_os_type',
-    platform
-  });
-
-  switch (platform) {
-    case 'win32':
-      return OSType.Windows;
-    case 'darwin':
-      return OSType.MacOS;
-    case 'linux':
-      return OSType.Linux;
-    default:
-      const error = `Unsupported operating system: ${platform}`;
-      Logger.error(error);
-      throw new Error(error);
-  }
-}
-
-export async function installCLI(tool: 'gh' | 'git'): Promise<void> {
-  const osType = getOSType();
-  Logger.debug({
-    action: 'install_cli',
-    tool,
-    osType
-  });
-
-  try {
-    switch (osType) {
-      case OSType.Windows:
-        if (tool === 'git') {
-          await execAsync('winget install --id Git.Git -e --source winget --silent');
-        } else {
-          await execAsync('winget install --id GitHub.cli --silent');
-        }
-        // Refresh PATH environment variable after installation
-        await refreshPathEnv();
-        break;
-
-      case OSType.MacOS:
-        if (tool === 'git') {
-          await execAsync('brew install git');
-        } else {
-          await execAsync('brew install gh');
-        }
-        // On macOS, we may need to source profile files
-        if (tool === 'git') {
-          await execAsync('source ~/.zshrc || source ~/.bash_profile || source ~/.bashrc || true');
-        }
-        break;
-
-      case OSType.Linux:
-        if (tool === 'git') {
-          await execAsync('sudo apt-get update && sudo apt-get install -y git');
-        } else {
-          await execAsync('curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && sudo apt update && sudo apt install -y gh');
-        }
-        // Source bash profile to refresh PATH
-        await execAsync('source ~/.bashrc || source ~/.profile || true');
-        break;
-
-      default:
-        throw new Error(`Unsupported operating system for installing ${tool}`);
-    }
-
-    // Wait a moment for system to register the new binaries
-    await new Promise(resolve => setTimeout(resolve, 1000));
-
-    Logger.debug({
-      action: 'install_cli_success',
-      tool,
-      osType
-    });
-  } catch (error) {
-    Logger.error('Failed to install CLI tool', {
-      tool,
-      osType,
-      error
-    });
-    throw error;
-  }
-}
-
-/**
- * Refreshes the PATH environment variable for the current Node.js process
- */
-export async function refreshPathEnv(): Promise<void> {
-  const osType = getOSType();
-  Logger.debug({
-    action: 'refresh_path_env',
-    osType
-  });
-
-  try {
-    switch (osType) {
-      case OSType.Windows:
-        // On Windows, get the PATH from registry
-        const { stdout: winPath } = await execAsync('powershell -command "[Environment]::GetEnvironmentVariable(\'Path\', \'Machine\') + \';\' + [Environment]::GetEnvironmentVariable(\'Path\', \'User\')"');
-        if (winPath) {
-          process.env.PATH = winPath.trim();
-          Logger.debug('Refreshed PATH from Windows registry');
-        }
-        break;
-
-      case OSType.MacOS:
-      case OSType.Linux:
-        // On Unix systems, typical installation locations if PATH isn't updated
-        const commonPaths = [
-          '/usr/local/bin',
-          '/usr/bin',
-          '/bin',
-          '/usr/sbin',
-          '/sbin',
-          '/usr/local/git/bin',
-          '/opt/homebrew/bin', // For M1 Macs
-          `${os.homedir()}/.local/bin`
-        ];
-
-        // Ensure these paths are in process.env.PATH
-        if (process.env.PATH) {
-          const currentPaths = process.env.PATH.split(':');
-          const newPaths = [...new Set([...currentPaths, ...commonPaths])];
-          process.env.PATH = newPaths.join(':');
-          Logger.debug('Expanded PATH with common Unix binary locations');
-        }
-        break;
-    }
-
-    Logger.debug({
-      action: 'refresh_path_env_success',
-      path: process.env.PATH
-    });
-  } catch (error) {
-    Logger.error('Failed to refresh PATH environment variable', error);
-    // Continue execution even if PATH refresh fails
-  }
-}
-
-/**
- * Check if a command is available on the system
- * Handles special cases for VS Code on different platforms
- */
-export async function isCommandAvailable(command: string): Promise<boolean> {
-  try {
-    // For VS Code on macOS, check both command-line tool and app bundle
-    if (process.platform === 'darwin' && (command === 'code' || command === 'code-insiders')) {
-      try {
-        // Try which command first
-        await execAsync(`which ${command}`);
-        return true;
-      } catch (error) {
-        // If which fails, check application bundles
-        const systemVSCodePath = command === 'code' ?
-          '/Applications/Visual Studio Code.app' :
-          '/Applications/Visual Studio Code - Insiders.app';
-
-        try {
-          // Check system Applications first
-          await execAsync(`test -d "${systemVSCodePath}"`);
-          return true;
-        } catch (error) {
-          // If system Applications check fails, try user Applications
-          const homedir = process.env.HOME;
-          if (homedir) {
-            const userVSCodePath = command === 'code' ?
-              `${homedir}/Applications/Visual Studio Code.app` :
-              `${homedir}/Applications/Visual Studio Code - Insiders.app`;
-
-            try {
-              await execAsync(`test -d "${userVSCodePath}"`);
-              return true;
-            } catch (error) {
-              return false;
-            }
-          }
-          return false;
-        }
-      }
-    }
-
-    // For Windows, use where command
-    if (process.platform === 'win32') {
-      await execAsync(`where ${command}`);
-      return true;
-    }
-
-    // For all other cases (Unix-like systems), use which command
-    await execAsync(`which ${command}`);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-export async function isToolInstalled(tool: 'gh' | 'git', retries = 3): Promise<boolean> {
-  try {
-    Logger.debug({
-      action: 'check_tool_installed',
-      tool,
-      retries
-    });
-
-    // Try to execute tool command
-    try {
-      await execAsync(`${tool} --version`);
-      Logger.debug({
-        action: 'check_tool_installed_success',
-        tool,
-        installed: true
-      });
-      return true;
-    } catch (error) {
-      // If we have retries left, refresh PATH and try again
-      if (retries > 0) {
-        Logger.debug(`${tool} not found, refreshing PATH and retrying...`);
-
-        // Refresh environment PATH variable
-        await refreshPathEnv();
-
-        // Wait a moment before retrying
-        await new Promise(resolve => setTimeout(resolve, 500));
-
-        // Recursive retry with decremented counter
-        return isToolInstalled(tool, retries - 1);
-      }
-
-      // No retries left, tool is not installed
-      Logger.debug({
-        action: 'check_tool_installed_success',
-        tool,
-        installed: false
-      });
-      return false;
-    }
-  } catch (error) {
-    Logger.error(`Error checking if ${tool} is installed`, error);
-    return false;
-  }
-}
-
-export async function openBrowser(url: string): Promise<void> {
-  const osType = getOSType();
-  Logger.debug({
-    action: 'open_browser',
-    url,
-    osType
-  });
-
-  try {
-    switch (osType) {
-      case OSType.Windows:
-        await execAsync(`start ${url}`);
-        break;
-      case OSType.MacOS:
-        await execAsync(`open ${url}`);
-        break;
-      case OSType.Linux:
-        // Try different commands that might be available
-        try {
-          await execAsync(`xdg-open ${url}`);
-        } catch (error) {
-          // Try alternative commands
-          try {
-            await execAsync(`sensible-browser ${url}`);
-          } catch (error) {
-            await execAsync(`gnome-open ${url}`);
-          }
-        }
-        break;
-      default:
-        throw new Error(`Unsupported operating system for opening browser`);
-    }
-
-    Logger.debug({
-      action: 'open_browser_success',
-      url,
-      osType
-    });
-  } catch (error) {
-    Logger.error('Failed to open browser', {
-      url,
-      osType,
-      error
-    });
-    // Don't throw the error - just log it and continue
-  }
-}
-
-export function getPythonPackagePath(pythonExecutablePath: string): string {
-  Logger.debug({
-    action: 'get_python_package_path',
-    pythonExecutablePath
-  });
-
-  try {
-    const dir = path.dirname(pythonExecutablePath);
-    const isWindows = process.platform === 'win32';
-
-    // Handle common Python installation patterns
-    if (isWindows) {
-      // Windows: Handle different Python installations
-      if (dir.endsWith('WindowsApps')) {
-        // For Windows Store Python, find the actual Python installation directory
-        const entries = fs.readdirSync(dir);
-        const pythonDir = entries.find(e => e.startsWith('PythonSoftwareFoundation.Python'));
-        if (pythonDir && pythonDir.includes('.')) {
-          // Extract version from format like "PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0"
-          const parts = pythonDir.split('.');
-          const majorVer = parts[2];
-          const minorVer = parts[3].split('_')[0];
-          const version = majorVer + minorVer; // Combines "3" and "13" to "313"
-          const localAppData = process.env.LOCALAPPDATA;
-
-          if (localAppData) {
-            const sitePkgsPath = path.join(
-              localAppData,
-              'Packages',
-              pythonDir,
-              'LocalCache',
-              'local-packages',
-              'Python' + version,
-              'site-packages'
-            );
-
-            Logger.debug(`Resolved Windows Store Python site-packages path: ${sitePkgsPath}`);
-            return sitePkgsPath;
-          }
-        }
-
-        Logger.debug('Could not resolve Windows Store Python site-packages path');
-        // Fallback to user's site-packages
-        return path.join(process.env.APPDATA || '', 'Python', 'Python3', 'site-packages');
-      } else if (dir.endsWith('Scripts')) {
-        // Virtual environment structure on Windows: <venv>/Scripts/python.exe
-        const venvRoot = path.dirname(dir);
-        return path.join(venvRoot, 'Lib', 'site-packages');
-      } else {
-        // System Python or Conda on Windows
-        return path.join(dir, 'Lib', 'site-packages');
-      }
-    } else {
-      // Unix systems (MacOS/Linux)
-      if (dir.endsWith('bin')) {
-        // Virtual environment structure on Unix: <venv>/bin/python
-        const venvRoot = path.dirname(dir);
-        // Try to find python version-specific site-packages
-        const libDir = path.join(venvRoot, 'lib');
-        if (fs.existsSync(libDir)) {
-          const pythonDirs = fs.readdirSync(libDir).filter(d => d.startsWith('python'));
-          if (pythonDirs.length > 0) {
-            // Use the first python directory found
-            return path.join(libDir, pythonDirs[0], 'site-packages');
-          }
-        }
-        // Fallback to a generic lib/python3/site-packages if version-specific not found
-        return path.join(venvRoot, 'lib', 'python3', 'site-packages');
-      } else if (dir.toLowerCase().includes('python')) {
-        // System Python or Conda on Unix
-        const libDir = path.join(dir, 'lib');
-        if (fs.existsSync(libDir)) {
-          const pythonDirs = fs.readdirSync(libDir).filter(d => d.startsWith('python'));
-          if (pythonDirs.length > 0) {
-            // Use the first python directory found
-            return path.join(libDir, pythonDirs[0], 'site-packages');
-          }
-        }
-        // Fallback to a generic lib/python3/site-packages
-        return path.join(dir, 'lib', 'python3', 'site-packages');
-      }
-    }
-
-    // Default fallback: return the original directory
-    Logger.debug('No standard Python directory structure found, using original directory');
-    return dir;
-  } catch (error) {
-    Logger.error('Error getting Python package path', {
-      pythonExecutablePath,
-      error
-    });
-    return path.dirname(pythonExecutablePath);
-  }
-}
-
-export async function getSystemPythonPackageDirectory(): Promise<string | null> {
-  const command = process.platform === 'win32' ? 'where python' : 'which python';
-
-  Logger.debug({
-    action: 'get_system_python_package_directory',
-    command
-  });
-
-  try {
-    const { stdout } = await execAsync(command);
-    // Use the first path found, trim whitespace
-    const pythonPath = stdout.split('\n')[0].trim();
-    if (pythonPath) {
-      const packagePath = getPythonPackagePath(pythonPath);
-      Logger.debug({
-        action: 'get_system_python_package_directory_success',
-        pythonPath,
-        packagePath
-      });
-      return packagePath;
-    }
-    Logger.debug('No Python executable found');
-    return null;
-  } catch (error) {
-    Logger.debug(`Could not find system python using "${command}": ${error}`);
-    return null;
-  }
-}
-/**
- * Get the system Python executable path.
- * This function returns the absolute path to the system Python executable (e.g., /Users/penwa/miniconda3/envs/browser-use-temp/bin/python).
- * It uses 'which python' (Unix) or 'where python' (Windows) to locate the executable.
- * @returns {Promise<string | null>} The path to the Python executable, or null if not found.
- */
-export async function getSystemPythonExecutablePath(): Promise<string | null> {
-  const command = process.platform === 'win32' ? 'where python' : 'which python';
-
-  Logger.debug({
-    action: 'get_system_python_executable_path',
-    command
-  });
-
-  try {
-    const { stdout } = await execAsync(command);
-    // Use the first path found, trim whitespace
-    const pythonPath = stdout.split('\n')[0].trim();
-    if (pythonPath) {
-      Logger.debug({
-        action: 'get_system_python_executable_path_success',
-        pythonPath
-      });
-      return pythonPath;
-    }
-    Logger.debug('No Python executable found');
-    return null;
-  } catch (error) {
-    Logger.debug(`Could not find system python using "${command}": ${error}`);
-    return null;
-  }
-}
-
-export async function getBrowserPath(): Promise<string> {
-  const osType = getOSType();
-  Logger.debug({
-    action: 'get_system_browser_path',
-    osType
-  });
-
-  try {
-    switch (osType) {
-      case OSType.Windows: {
-        // Check for Edge first
-        const edgePaths = [
-          `${process.env['PROGRAMFILES(X86)']}\\Microsoft\\Edge\\Application\\msedge.exe`,
-          `${process.env['PROGRAMFILES']}\\Microsoft\\Edge\\Application\\msedge.exe`
-        ];
-        for (const path of edgePaths) {
-          if (fs.existsSync(path)) {
-            return path;
-          }
-        }
-
-        // Then check for Chrome
-        const chromePaths = [
-          `${process.env['PROGRAMFILES(X86)']}\\Google\\Chrome\\Application\\chrome.exe`,
-          `${process.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`
-        ];
-        for (const path of chromePaths) {
-          if (fs.existsSync(path)) {
-            return path;
-          }
-        }
-        break;
-      }
-
-      case OSType.MacOS: {
-        // Check for Edge first
-        const edgePath = '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge';
-        if (fs.existsSync(edgePath)) {
-          return edgePath;
-        }
-
-        // Then check for Chrome
-        const chromePath = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
-        if (fs.existsSync(chromePath)) {
-          return chromePath;
-        }
-
-        // Finally check for Safari
-        const safariPath = '/Applications/Safari.app/Contents/MacOS/Safari';
-        if (fs.existsSync(safariPath)) {
-          return safariPath;
-        }
-        break;
-      }
-
-      case OSType.Linux: {
-        // Try Edge first
-        try {
-          const { stdout: edgePath } = await execAsync('which microsoft-edge');
-          if (edgePath.trim()) {
-            return edgePath.trim();
-          }
-        } catch { }
-
-        // Then try Chrome or Chromium
-        try {
-          const { stdout: chromePath } = await execAsync('which google-chrome chromium');
-          if (chromePath.trim()) {
-            return chromePath.trim();
-          }
-        } catch { }
-        break;
-      }
-    }
-
-    // If no browser found, throw error
-    throw new Error('No supported browser found on the system');
-  } catch (error) {
-    Logger.error('Failed to get browser path', error);
-    throw error;
-  }
-}
-
-/**
- * Get the global NPM path
- * This function checks if NVM is installed and retrieves the global NPM path accordingly.
- * If NVM is not installed, it falls back to the global NPM path.
- * @returns The global NPM path as a string.
- * @throws Error if the NPM path cannot be determined.
- * */
-export function getGlobalNPMPackagePath(): string {
-  const nvmHome = process.env.NVM_HOME;
-  if (nvmHome) {
-    try {
-      const nodeVersion = execSync('node -v').toString().trim();
-      const nvmNodePath = path.join(nvmHome, nodeVersion);
-      // Check if this path exists
-      try {
-        fsSync.accessSync(nvmNodePath);
-        return nvmNodePath;
-      } catch (error) {
-        Logger.debug(`NVM controlled path doesn't exist: ${nvmNodePath}, will try global npm`);
-      }
-    } catch (error) {
-      Logger.debug(`Error determining Node version for NVM: ${error}, will use global npm`);
-    }
-  }
-
-  const globalNpmPath = execSync('npm root -g').toString().trim();
-  return globalNpmPath;
-}
-
-
-/**
- * Get the NPM executable path on the current platform (Windows, macOS, Linux).
- * On Windows, uses PowerShell to locate npm. On macOS/Linux, uses 'which' to locate npm.
- * Returns the directory containing the npm executable, or a platform-appropriate default if not found.
- */
-export async function getNpmExecutablePath(): Promise<string> {
-  try {
-    if (process.platform === 'win32') {
-      const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
-      return stdout.trim().replace(/\\npm\.cmd$/, '');
-    } else {
-      // macOS or Linux
-      const { stdout } = await execAsync('which npm');
-      // Remove the trailing '/npm' to get the directory
-      return stdout.trim().replace(/\/npm$/, '');
-    }
-  } catch (error) {
-    Logger.error('Error getting npm path:', error);
-    if (process.platform === 'win32') {
-      return 'C:\\Program Files\\nodejs';
-    } else {
-      // Common default for Unix systems
-      return '/usr/local/bin';
-    }
-  }
-}
-
-/**
- * Ensures the .NET global tools path is added to the system PATH for the current user
- * on macOS and Linux by modifying shell configuration files.
- * This function is idempotent and will not add the path if it already exists.
- */
-export async function ensureDotnetToolsInPath(): Promise<void> {
-  const osType = getOSType();
-  Logger.debug({
-    action: 'ensure_dotnet_tools_in_path',
-    osType
-  });
-
-  if (osType === OSType.Windows) {
-    Logger.debug('.NET tools PATH is usually handled by the installer on Windows. Skipping explicit PATH modification.');
-    return;
-  }
-
-  if (osType === OSType.MacOS || osType === OSType.Linux) {
-    const dotnetToolsPath = getDotnetGlobalToolsPath(); // This is typically ~/.dotnet/tools
-    const exportLine = `export PATH="${dotnetToolsPath}:$PATH"`;
-
-    // Determine shell configuration files to check/update
-    const shellConfigFiles: string[] = [];
-    const shell = process.env.SHELL;
-
-    if (shell && shell.includes('zsh')) {
-      shellConfigFiles.push(path.join(os.homedir(), '.zshrc'));
-    } else if (shell && shell.includes('bash')) {
-      shellConfigFiles.push(path.join(os.homedir(), '.bashrc'));
-      // .bash_profile is often sourced by .bashrc or used for login shells
-      shellConfigFiles.push(path.join(os.homedir(), '.bash_profile'));
-    } else {
-      // Fallback for other shells or if SHELL is not set
-      shellConfigFiles.push(path.join(os.homedir(), '.profile'));
-      shellConfigFiles.push(path.join(os.homedir(), '.bashrc'));
-      shellConfigFiles.push(path.join(os.homedir(), '.zshrc'));
-    }
-    
-    let updatedAnyFile = false;
-
-    for (const configFile of shellConfigFiles) {
-      try {
-        if (fs.existsSync(configFile)) {
-          const content = await fs.promises.readFile(configFile, 'utf-8');
-          // Check if the exact line or a line setting dotnetToolsPath in PATH exists
-          // A more robust check might involve parsing, but this covers common cases.
-          // Regex to check if dotnetToolsPath is part of an PATH export, avoiding duplicates.
-          // It looks for `export PATH=...$dotnetToolsPath...` or `export PATH=...${HOME}/.dotnet/tools...`
-          const pathRegex = new RegExp(`export\\s+PATH=.*${dotnetToolsPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*`);
-          const homePathRegex = new RegExp(`export\\s+PATH=.*\\$HOME\\/\\.dotnet\\/tools.*`);
-
-          if (!pathRegex.test(content) && !homePathRegex.test(content)) {
-            Logger.debug(`Adding .NET tools path to ${configFile}`);
-            await fs.promises.appendFile(configFile, `\n# Add .NET Core SDK tools to PATH\n${exportLine}\n`);
-            Logger.log(`Appended '${exportLine}' to ${configFile}. You may need to source this file or restart your terminal.`);
-            updatedAnyFile = true;
-          } else {
-            Logger.debug(`.NET tools path already configured in ${configFile}`);
-          }
-        } else if (shellConfigFiles.length === 1 || configFile === path.join(os.homedir(), '.profile')) {
-          // If it's the only config file determined or it's .profile, and it doesn't exist, create it.
-          Logger.debug(`${configFile} does not exist. Creating and adding .NET tools path.`);
-          await fs.promises.writeFile(configFile, `# Add .NET Core SDK tools to PATH\n${exportLine}\n`);
-          Logger.log(`Created ${configFile} and added '${exportLine}'. You may need to source this file or restart your terminal.`);
-          updatedAnyFile = true;
-        }
-      } catch (error) {
-        Logger.error(`Failed to update ${configFile} for .NET tools PATH: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-    if (updatedAnyFile) {
-        Logger.log(`Dotnet tools path has been added to shell configuration. Please source the relevant file (e.g., 'source ~/.zshrc') or restart your terminal session for changes to take effect.`);
-    }
-
-    // Also update the current process's PATH environment variable
-    if (process.env.PATH && !process.env.PATH.includes(dotnetToolsPath)) {
-      process.env.PATH = `${dotnetToolsPath}:${process.env.PATH}`;
-      Logger.debug(`Updated current process.env.PATH to include: ${dotnetToolsPath}`);
-    } else if (!process.env.PATH) {
-      process.env.PATH = dotnetToolsPath;
-      Logger.debug(`Set current process.env.PATH to: ${dotnetToolsPath}`);
-    }
-  }
-}
-/**
- * 
- * @returns The path to the .dotnet global tools directory.
- */
-export function getDotnetGlobalToolsPath(): string {
-  const homeDir = os.homedir();
-
-  if (process.platform === 'win32') {
-    // Example: C:\Users\YourName\.dotnet\tools
-    return path.join(homeDir, '.dotnet', 'tools');
-  } else if (process.platform === 'darwin' || process.platform === 'linux') {
-    // macOS or Linux: ~/.dotnet/tools
-    return path.join(homeDir, '.dotnet', 'tools');
-  } else {
-    throw new Error(`Unsupported platform: ${process.platform}`);
-  }
-}
-