imcp 0.1.3 → 0.1.5

package/src/utils/macroExpressionUtils.ts

@@ -1,104 +0,0 @@
-import { Logger } from './logger.js';
-import { getPythonPackagePath, getSystemPythonPackageDirectory, getBrowserPath, getGlobalNPMPackagePath } from './osUtils.js';
-import { ServerInstallOptions } from '../core/metadatas/types.js'; // Adjusted path
-import { SystemSettingsManager } from '../core/loaders/SystemSettingsManager.js';
-import * as fsSync from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-
-export const MACRO_EXPRESSIONS = {
-    PYTHON_PACKAGE: '${PYTHON_PACKAGE}',
-    NPMPATH: '${NPMPATH}',
-    BROWSER_PATH: '${BROWSER_PATH}',
-} as const;
-
-// Define a map for macro keys to their resolver functions
-export const MacroResolverFunctions: {
-    [key: string]: (finalConfig: any, options: ServerInstallOptions) => Promise<string | undefined>;
-} = {
-    [MACRO_EXPRESSIONS.PYTHON_PACKAGE]: resolvePythonPackageMacro,
-    [MACRO_EXPRESSIONS.NPMPATH]: resolveNpmPathMacro,
-    [MACRO_EXPRESSIONS.BROWSER_PATH]: resolveBrowserPathMacro,
-};
-
-/**
- * Resolves the path for the ${PYTHON_PACKAGE} macro.
- * It considers the pythonEnv setting and falls back to system Python.
- * Also updates finalConfig.command if it's 'python' and pythonEnv is used.
- * @param finalConfig The configuration object (mutated for command).
- * @param options Server installation options.
- * @returns The resolved Python package path or undefined.
- */
-export async function resolvePythonPackageMacro(finalConfig: any, options: ServerInstallOptions): Promise<string | undefined> {
-    const pythonEnv = options.settings?.pythonEnv;
-    if (pythonEnv) {
-        Logger.debug(`Python environment specified for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}: ${pythonEnv}`);
-        const pythonDir = getPythonPackagePath(pythonEnv);
-        if (pythonDir) {
-            if (finalConfig.command === 'python') {
-                Logger.debug(`Replacing command 'python' with specified pythonEnv: ${pythonEnv} due to ${MACRO_EXPRESSIONS.PYTHON_PACKAGE} resolution`);
-                finalConfig.command = pythonEnv;
-            }
-            return pythonDir;
-        }
-        Logger.debug(`Could not determine directory for pythonEnv: ${pythonEnv}. ${MACRO_EXPRESSIONS.PYTHON_PACKAGE} will not be replaced using this path.`);
-        return undefined;
-    } else {
-        Logger.debug(`No Python environment specified. Attempting to find system Python for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}.`);
-        const pythonDir = await getSystemPythonPackageDirectory();
-        if (pythonDir) {
-            return pythonDir;
-        }
-        Logger.debug(`Could not find system Python directory for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}.`);
-        return undefined;
-    }
-}
-
-/**
- * Resolves the actual NPM module path.
- * It checks a provided path, then NVM, then global npm.
- * @param providedNpmPath An optional, pre-configured NPM path.
- * @returns The resolved NPM module path or undefined if an error occurs.
- */
-export function resolveNpmModulePath(providedNpmPath: string | undefined): string {
-    if (providedNpmPath) {
-        return `${providedNpmPath}/node_modules`;
-    }
-
-    const globalNpmPath = getGlobalNPMPackagePath();
-    Logger.debug(`Resolved ${MACRO_EXPRESSIONS.NPMPATH} via global npm to: ${globalNpmPath}`);
-    return globalNpmPath;
-}
-
-/**
- * Resolves the path to an NPM module for the ${NPMPATH} macro.
- * Uses the resolveNpmModulePath function.
- * @param _finalConfig Not used by this resolver.
- * @param options Server installation options, may contain npmPath.
- * @returns The resolved NPM path or undefined if an error occurs.
- */
-export async function resolveNpmPathMacro(_finalConfig: any, options: ServerInstallOptions): Promise<string | undefined> {
-    Logger.debug(`Resolving ${MACRO_EXPRESSIONS.NPMPATH}. Provided npmPath from settings: ${options.settings?.npmPath}`);
-    try {
-        return resolveNpmModulePath(options.settings?.npmPath);
-    } catch (error) {
-        Logger.error(`Failed to resolve ${MACRO_EXPRESSIONS.NPMPATH}:`, error);
-        return undefined;
-    }
-}
-
-/**
- * Resolves the path for the ${BROWSER_PATH} macro.
- * @returns The system's browser path or undefined.
- */
-export async function resolveBrowserPathMacro(): Promise<string | undefined> {
-    Logger.debug(`Resolving ${MACRO_EXPRESSIONS.BROWSER_PATH}`);
-    try {
-        const browserPath = await getBrowserPath();
-        Logger.debug(`Resolved ${MACRO_EXPRESSIONS.BROWSER_PATH} to: ${browserPath}`);
-        return browserPath;
-    } catch (error) {
-        Logger.error(`Failed to get system browser path for ${MACRO_EXPRESSIONS.BROWSER_PATH}:`, error);
-        return undefined;
-    }
-}

package/src/utils/osUtils.ts

@@ -1,597 +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';
-    }
-  }
-}