imcp 0.0.3 → 0.0.5

package/dist/core/installers/ClientInstaller.js

@@ -1,9 +1,12 @@
+import { GetBrowserPath } from '../../utils/osUtils.js';
 import { ConfigurationProvider } from '../ConfigurationProvider.js';
 import { SUPPORTED_CLIENTS } from '../constants.js';
 import { resolveNpmModulePath, readJsonFile, writeJsonFile } from '../../utils/clientUtils.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { Logger } from '../../utils/logger.js';
+import { getPythonPackagePath, getSystemPythonPackageDirectory } from '../../utils/osUtils.js';
+const execAsync = promisify(exec); // Moved promisify here for reuse
 export class ClientInstaller {
     categoryName;
     serverName;
@@ -21,7 +24,6 @@ export class ClientInstaller {
         return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
     async getNpmPath() {
-        const execAsync = promisify(exec);
         try {
             // Execute the get-command npm command to find the npm path
             const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
@@ -41,12 +43,18 @@ export class ClientInstaller {
      * @returns True if the command is available, false otherwise
      */
     async isCommandAvailable(command) {
-        const execAsync = promisify(exec);
         try {
             if (process.platform === 'win32') {
                 // Windows-specific command check
                 await execAsync(`where ${command}`);
             }
+            else if (process.platform === 'darwin' && (command === 'code' || command === 'code-insiders')) {
+                // macOS-specific VS Code check
+                const vscodePath = command === 'code' ?
+                    '/Applications/Visual Studio Code.app' :
+                    '/Applications/Visual Studio Code - Insiders.app';
+                await execAsync(`test -d "${vscodePath}"`);
+            }
             else {
                 // Unix-like systems
                 await execAsync(`which ${command}`);
@@ -54,10 +62,25 @@ export class ClientInstaller {
             return true;
         }
         catch (error) {
+            if (process.platform === 'darwin' && (command === 'code' || command === 'code-insiders')) {
+                // Try checking in ~/Applications as well for macOS
+                try {
+                    const homedir = process.env.HOME;
+                    const vscodePath = command === 'code' ?
+                        `${homedir}/Applications/Visual Studio Code.app` :
+                        `${homedir}/Applications/Visual Studio Code - Insiders.app`;
+                    await execAsync(`test -d "${vscodePath}"`);
+                    return true;
+                }
+                catch (error) {
+                    return false;
+                }
+            }
             return false;
         }
     }
-    async installClient(clientName, env) {
+    // Modified to accept ServerInstallOptions
+    async installClient(clientName, options) {
         // Check if client is supported
         if (!SUPPORTED_CLIENTS[clientName]) {
             return {
@@ -80,11 +103,13 @@ export class ClientInstaller {
         // Update server status with initial client installation status
         await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, initialStatus);
         // Start the asynchronous installation process without awaiting it
-        this.processInstallation(clientName, operationId, env);
+        // Pass options down
+        this.processInstallation(clientName, operationId, options);
         // Return the initial status immediately
         return initialStatus;
     }
-    async processInstallation(clientName, operationId, env) {
+    // Modified to accept ServerInstallOptions
+    async processInstallation(clientName, operationId, options) {
         try {
             // Check requirements before installation
             let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
@@ -158,8 +183,8 @@ export class ClientInstaller {
                 return;
             }
             try {
-                // Install client-specific configuration
-                const result = await this.installClientConfig(clientName, env || {}, serverConfig, feedConfiguration);
+                // Install client-specific configuration, passing options down
+                const result = await this.installClientConfig(clientName, options, serverConfig, feedConfiguration);
                 const finalStatus = {
                     status: result.success ? 'completed' : 'failed',
                     type: 'install',
@@ -169,6 +194,9 @@ export class ClientInstaller {
                     error: result.success ? undefined : result.message
                 };
                 await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, finalStatus);
+                if (result.success) {
+                    await this.configProvider.reloadClientMCPSettings();
+                }
             }
             catch (error) {
                 const errorStatus = {
@@ -194,7 +222,9 @@ export class ClientInstaller {
             await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, errorStatus);
         }
     }
-    async installClientConfig(clientName, env, serverConfig, feedConfig) {
+    // Modified to accept ServerInstallOptions
+    async installClientConfig(clientName, options, // Use options directly
+    serverConfig, feedConfig) {
         try {
             if (!SUPPORTED_CLIENTS[clientName]) {
                 Logger.debug(`Client ${clientName} is not supported.`);
@@ -212,7 +242,6 @@ export class ClientInstaller {
             const isVSCodeInsidersInstalled = await this.isCommandAvailable('code-insiders');
             Logger.debug(isVSCodeInstalled ? 'VS Code detected on system' : 'VS Code not detected on system');
             Logger.debug(isVSCodeInsidersInstalled ? 'VS Code Insiders detected on system' : 'VS Code Insiders not detected on system');
-            Logger.debug(`VS Code Insiders installed: ${isVSCodeInsidersInstalled}`);
             // If neither is installed, we can't proceed
             if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
                 Logger.debug('No VS Code installations detected on system. Cannot update settings.');
@@ -221,25 +250,95 @@ export class ClientInstaller {
                     message: `Neither VS Code nor VS Code Insiders are installed on this system. Cannot update settings for client: ${clientName}. Please install VS Code or VS Code Insiders and try again.`
                 };
             }
-            // Clone the installation configuration to make modifications
+            // --- Start of new logic ---
+            // Clone the base installation configuration to avoid modifying the original serverConfig
             const installConfig = JSON.parse(JSON.stringify(serverConfig.installation));
-            // Replace template variables in args
-            installConfig.args = installConfig.args.map((arg) => resolveNpmModulePath(arg));
-            // Add environment variables from options
-            installConfig.env = {};
-            if (serverConfig.installation.env) {
-                // Add default env variables from config
-                for (const [key, config] of Object.entries(serverConfig.installation.env)) {
-                    const envConfig = config; // Type assertion for dynamic access
-                    if (envConfig.Default) {
-                        installConfig.env[key] = envConfig.Default;
+            const pythonEnv = options.settings?.pythonEnv;
+            let pythonDir = null;
+            // 1. Determine which args to use and resolve npm paths
+            let finalArgs = [];
+            if (options.args && options.args.length > 0) {
+                Logger.debug(`Using args from ServerInstallOptions: ${options.args.join(' ')}`);
+                finalArgs = options.args.map(arg => resolveNpmModulePath(arg));
+            }
+            else if (installConfig.args && installConfig.args.length > 0) {
+                Logger.debug(`Using args from serverConfig.installation: ${installConfig.args.join(' ')}`);
+                finalArgs = installConfig.args.map((arg) => resolveNpmModulePath(arg));
+            }
+            else {
+                Logger.debug('No args found in options or serverConfig.installation.');
+                finalArgs = [];
+            }
+            // 2. Handle pythonEnv settings
+            if (pythonEnv) {
+                // 2.1 If pythonEnv is set
+                Logger.debug(`Python environment specified: ${pythonEnv}`);
+                pythonDir = getPythonPackagePath(pythonEnv);
+                // 2.1.1 Replace ${PYTHON_PACKAGE} in args
+                if (pythonDir) {
+                    finalArgs = finalArgs.map(arg => arg.includes('${PYTHON_PACKAGE}') ? arg.replace('${PYTHON_PACKAGE}', pythonDir) : arg);
+                    Logger.debug(`Args after PYTHON_PACKAGE replacement (using pythonEnv): ${finalArgs.join(' ')}`);
+                }
+                else {
+                    Logger.debug(`Could not determine directory for pythonEnv: ${pythonEnv}`);
+                }
+                // 2.1.2 Replace command if it's 'python'
+                if (installConfig.command === 'python') {
+                    Logger.debug(`Replacing command 'python' with specified pythonEnv: ${pythonEnv}`);
+                    installConfig.command = pythonEnv;
+                }
+            }
+            else {
+                // 2.2 If pythonEnv is not set
+                Logger.debug('No Python environment specified in settings.');
+                // 2.2.1 Replace ${PYTHON_PACKAGE} with system python directory if needed
+                if (finalArgs.some(arg => arg.includes('${PYTHON_PACKAGE}'))) {
+                    Logger.debug('Attempting to find system Python directory for ${PYTHON_PACKAGE} replacement.');
+                    pythonDir = await getSystemPythonPackageDirectory();
+                    if (pythonDir) {
+                        finalArgs = finalArgs.map(arg => arg.includes('${PYTHON_PACKAGE}') ? arg.replace('${PYTHON_PACKAGE}', pythonDir) : arg);
+                        Logger.debug(`Args after PYTHON_PACKAGE replacement (using system python): ${finalArgs.join(' ')}`);
+                    }
+                    else {
+                        Logger.debug('Could not find system Python directory. ${PYTHON_PACKAGE} replacement skipped.');
+                        // Optionally, remove or handle the arg containing ${PYTHON_PACKAGE} if Python is required
+                        // finalArgs = finalArgs.filter(arg => !arg.includes('${PYTHON_PACKAGE}'));
                     }
                 }
             }
-            // Override with provided env variables
-            if (env) {
-                Object.assign(installConfig.env, env);
+            // Update installConfig with potentially modified args
+            installConfig.args = finalArgs;
+            // 3. Handle environment variables (merge default, serverConfig, and options.env)
+            const baseEnv = serverConfig.installation.env || {};
+            const defaultEnv = {};
+            for (const [key, config] of Object.entries(baseEnv)) {
+                const envConfig = config; // Type assertion
+                if (envConfig.Default) {
+                    defaultEnv[key] = envConfig.Default;
+                }
             }
+            // Merge: options.env overrides defaultEnv
+            installConfig.env = { ...defaultEnv, ...(options.env || {}) };
+            // Replace ${BROWSER_PATH} with actual browser path
+            const replacements = Object.entries(installConfig.env)
+                .filter(([_, value]) => typeof value === 'string' && value.includes('${BROWSER_PATH}'))
+                .map(async ([key, value]) => {
+                try {
+                    const browserPath = await GetBrowserPath();
+                    return [key, value.replace('${BROWSER_PATH}', browserPath)];
+                }
+                catch (error) {
+                    Logger.error(`Failed to get system browser path for env var ${key}:`, error);
+                    return [key, value];
+                }
+            });
+            // Wait for all replacements to complete
+            const replacedValues = await Promise.all(replacements);
+            replacedValues.forEach(([key, value]) => {
+                installConfig.env[key] = value;
+            });
+            Logger.debug(`Final environment variables: ${JSON.stringify(installConfig.env)}`);
+            // --- End of new logic ---
             // Keep track of success for both installations
             let regularSuccess = false;
             let insidersSuccess = false;
@@ -250,6 +349,7 @@ export class ClientInstaller {
                 if (isVSCodeInstalled) {
                     try {
                         Logger.debug(`Updating VS Code settings for ${clientName} at path: ${regularSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateClineOrMSRooSettings(regularSettingPath, this.serverName, installConfig, clientName);
                         regularSuccess = true;
                         Logger.debug(`Settings successfully updated to ${regularSettingPath} for ${clientName} (VS Code)`);
@@ -264,6 +364,7 @@ export class ClientInstaller {
                 if (isVSCodeInsidersInstalled) {
                     try {
                         Logger.debug(`Updating VS Code Insiders settings for ${clientName} at path: ${insidersSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateClineOrMSRooSettings(insidersSettingPath, this.serverName, installConfig, clientName);
                         insidersSuccess = true;
                         Logger.debug(`Settings successfully updated to ${insidersSettingPath} for ${clientName} (VS Code Insiders)`);
@@ -280,6 +381,7 @@ export class ClientInstaller {
                 if (isVSCodeInstalled) {
                     try {
                         Logger.debug(`Updating VS Code settings for ${clientName} at path: ${regularSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateGithubCopilotSettings(regularSettingPath, this.serverName, installConfig);
                         regularSuccess = true;
                         Logger.debug(`Settings successfully updated to ${regularSettingPath} for ${clientName} (VS Code)`);
@@ -294,6 +396,7 @@ export class ClientInstaller {
                 if (isVSCodeInsidersInstalled) {
                     try {
                         Logger.debug(`Updating VS Code Insiders settings for ${clientName} at path: ${insidersSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateGithubCopilotSettings(insidersSettingPath, this.serverName, installConfig);
                         insidersSuccess = true;
                         Logger.debug(`Settings successfully updated to ${insidersSettingPath} for ${clientName} (VS Code Insiders)`);
@@ -365,7 +468,8 @@ export class ClientInstaller {
             };
         }
     }
-    async updateClineOrMSRooSettings(settingPath, serverName, installConfig, clientName) {
+    async updateClineOrMSRooSettings(settingPath, serverName, installConfig, // Use the processed installConfig
+    clientName) {
         // Read the Cline/MSRoo settings file
         const settings = await readJsonFile(settingPath, true);
         // Initialize mcpServers section if it doesn't exist
@@ -373,35 +477,43 @@ export class ClientInstaller {
             settings.mcpServers = {};
         }
         // Special handling for Windows when command is npx for Cline and MSROO clients
-        const serverConfig = { ...installConfig };
+        // Use a copy to avoid modifying the passed installConfig directly if needed elsewhere
+        const serverConfigForClient = { ...installConfig };
         if (process.platform === 'win32' &&
-            serverConfig.command === 'npx' &&
+            serverConfigForClient.command === 'npx' &&
             (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
             // Update command to cmd
-            serverConfig.command = 'cmd';
+            serverConfigForClient.command = 'cmd';
             // Add /c and npx at the beginning of args
-            serverConfig.args = ['/c', 'npx', ...serverConfig.args];
+            serverConfigForClient.args = ['/c', 'npx', ...serverConfigForClient.args];
             // Add APPDATA environment variable pointing to npm directory
-            if (!serverConfig.env) {
-                serverConfig.env = {};
+            if (!serverConfigForClient.env) {
+                serverConfigForClient.env = {};
             }
             // Dynamically get npm path and set APPDATA to it
             const npmPath = await this.getNpmPath();
-            serverConfig.env['APPDATA'] = npmPath;
+            serverConfigForClient.env['APPDATA'] = npmPath;
+            Logger.debug(`Windows npx fix: command=${serverConfigForClient.command}, args=${serverConfigForClient.args.join(' ')}, env=${JSON.stringify(serverConfigForClient.env)}`);
+        }
+        // Convert backslashes to forward slashes in args paths
+        if (serverConfigForClient.args) {
+            serverConfigForClient.args = serverConfigForClient.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
         }
         // Add or update the server configuration
         settings.mcpServers[serverName] = {
-            command: serverConfig.command,
-            args: serverConfig.args,
-            env: serverConfig.env,
+            command: serverConfigForClient.command,
+            args: serverConfigForClient.args,
+            env: serverConfigForClient.env,
             autoApprove: [],
             disabled: false,
             alwaysAllow: []
         };
+        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcpServers[serverName])}`);
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);
     }
-    async updateGithubCopilotSettings(settingPath, serverName, installConfig) {
+    async updateGithubCopilotSettings(settingPath, serverName, installConfig // Use the processed installConfig
+    ) {
         // Read the VS Code settings.json file
         const settings = await readJsonFile(settingPath, true);
         // Initialize the mcp section if it doesn't exist
@@ -414,20 +526,28 @@ export class ClientInstaller {
         if (!settings.mcp.servers) {
             settings.mcp.servers = {};
         }
+        // Use a copy to avoid modifying the passed installConfig directly
+        const serverConfigForClient = { ...installConfig };
+        // Convert backslashes to forward slashes in args paths
+        if (serverConfigForClient.args) {
+            serverConfigForClient.args = serverConfigForClient.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
+        }
         // Add or update the server configuration
         settings.mcp.servers[serverName] = {
-            command: installConfig.command,
-            args: installConfig.args,
-            env: installConfig.env
+            command: serverConfigForClient.command,
+            args: serverConfigForClient.args,
+            env: serverConfigForClient.env
         };
+        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcp.servers[serverName])}`);
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);
     }
     async install(options) {
         const initialStatuses = [];
         // Start installation for each client asynchronously and collect initial statuses
+        // Pass options down to installClient
         const installPromises = this.clients.map(async (clientName) => {
-            const initialStatus = await this.installClient(clientName, options.env || {});
+            const initialStatus = await this.installClient(clientName, options);
             initialStatuses.push(initialStatus);
             return initialStatus;
         });

package/dist/core/installers/CommandInstaller.d.ts

@@ -15,6 +15,7 @@ export declare class CommandInstaller extends BaseInstaller {
      * @returns True if this installer can handle the requirement
      */
     canHandle(requirement: RequirementConfig): boolean;
+    supportCheckUpdates(): boolean;
     /**
      * Get the mapped package ID for a command
      * @param commandName The command name to map

package/dist/core/installers/CommandInstaller.js

@@ -22,6 +22,9 @@ export class CommandInstaller extends BaseInstaller {
     canHandle(requirement) {
         return requirement.type === 'command';
     }
+    supportCheckUpdates() {
+        return false;
+    }
     /**
      * Get the mapped package ID for a command
      * @param commandName The command name to map

package/dist/core/installers/GeneralInstaller.d.ts

@@ -11,6 +11,7 @@ export declare class GeneralInstaller extends BaseInstaller {
      * @returns True if this installer can handle the requirement
      */
     canHandle(requirement: RequirementConfig): boolean;
+    supportCheckUpdates(): boolean;
     /**
      * Check if the requirement is already installed
      * For general installers, we can't easily check if something is installed

package/dist/core/installers/GeneralInstaller.js

@@ -12,6 +12,9 @@ export class GeneralInstaller extends BaseInstaller {
     canHandle(requirement) {
         return requirement.type === 'other';
     }
+    supportCheckUpdates() {
+        return false;
+    }
     /**
      * Check if the requirement is already installed
      * For general installers, we can't easily check if something is installed

package/dist/core/installers/InstallerFactory.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../types.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 import { exec } from 'child_process';
 /**
@@ -34,15 +34,17 @@ export declare class InstallerFactory {
     /**
      * Install a requirement using the appropriate installer
      * @param requirement The requirement to install
+     * @param options Installation options including python environment
      * @returns The installation status
      */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
-     * Check the installation status of a requirement
-     * @param requirement The requirement to check
-     * @returns The installation status
-     */
-    checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+      * Check the installation status of a requirement
+      * @param requirement The requirement to check
+      * @param options Installation options including python environment
+      * @returns The installation status
+      */
+    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
 }
 /**
  * Create a new InstallerFactory with default settings

package/dist/core/installers/InstallerFactory.js

@@ -50,9 +50,10 @@ export class InstallerFactory {
     /**
      * Install a requirement using the appropriate installer
      * @param requirement The requirement to install
+     * @param options Installation options including python environment
      * @returns The installation status
      */
-    async install(requirement) {
+    async install(requirement, options) {
         const installer = this.getInstaller(requirement);
         if (!installer) {
             return {
@@ -63,14 +64,15 @@ export class InstallerFactory {
                 inProgress: false
             };
         }
-        return await installer.install(requirement);
+        return await installer.install(requirement, options);
     }
     /**
-     * Check the installation status of a requirement
-     * @param requirement The requirement to check
-     * @returns The installation status
-     */
-    async checkInstallation(requirement) {
+      * Check the installation status of a requirement
+      * @param requirement The requirement to check
+      * @param options Installation options including python environment
+      * @returns The installation status
+      */
+    async checkInstallation(requirement, options) {
         const installer = this.getInstaller(requirement);
         if (!installer) {
             return {
@@ -81,7 +83,7 @@ export class InstallerFactory {
                 inProgress: false
             };
         }
-        return await installer.checkInstallation(requirement);
+        return await installer.checkInstallation(requirement, options);
     }
 }
 /**

package/dist/core/installers/NpmInstaller.d.ts

@@ -10,6 +10,7 @@ export declare class NpmInstaller extends BaseInstaller {
      * @returns True if this installer can handle the requirement
      */
     canHandle(requirement: RequirementConfig): boolean;
+    supportCheckUpdates(): boolean;
     /**
      * Check if the NPM package is already installed
      * @param requirement The requirement to check

package/dist/core/installers/NpmInstaller.js

@@ -12,6 +12,9 @@ export class NpmInstaller extends BaseInstaller {
     canHandle(requirement) {
         return requirement.type === 'npm';
     }
+    supportCheckUpdates() {
+        return true;
+    }
     /**
      * Check if the NPM package is already installed
      * @param requirement The requirement to check

package/dist/core/installers/PipInstaller.d.ts

@@ -1,25 +1,28 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for Python packages using pip
  */
 export declare class PipInstaller extends BaseInstaller {
+    private getPythonCommand;
+    private getPipCommand;
     /**
      * Check if this installer can handle the given requirement type
      * @param requirement The requirement to check
      * @returns True if this installer can handle the requirement
      */
     canHandle(requirement: RequirementConfig): boolean;
+    supportCheckUpdates(): boolean;
     /**
      * Check if the Python package is already installed
      * @param requirement The requirement to check
      * @returns The status of the requirement
      */
-    checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Install the Python package
      * @param requirement The requirement to install
      * @returns The status of the installation
      */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
 }

package/dist/core/installers/PipInstaller.js

@@ -3,6 +3,13 @@ import { BaseInstaller } from './BaseInstaller.js';
  * Installer implementation for Python packages using pip
  */
 export class PipInstaller extends BaseInstaller {
+    getPythonCommand(options) {
+        return options?.settings?.pythonEnv || 'python';
+    }
+    getPipCommand(options) {
+        const pythonCmd = this.getPythonCommand(options);
+        return `${pythonCmd} -m pip`;
+    }
     /**
      * Check if this installer can handle the given requirement type
      * @param requirement The requirement to check
@@ -11,14 +18,19 @@ export class PipInstaller extends BaseInstaller {
     canHandle(requirement) {
         return requirement.type === 'pip';
     }
+    supportCheckUpdates() {
+        /// temporarily disabling update check for pip as not able to get which pip of python is being used
+        return false;
+    }
     /**
      * Check if the Python package is already installed
      * @param requirement The requirement to check
      * @returns The status of the requirement
      */
-    async checkInstallation(requirement) {
+    async checkInstallation(requirement, options) {
         try {
-            const { stdout, stderr } = await this.execPromise(`pip show ${requirement.name}`);
+            const pipCmd = this.getPipCommand(options);
+            const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
             // If we get an output and no error, the package is installed
             const installed = stdout.includes(requirement.name);
             const versionMatch = stdout.match(/Version: (.+)/);
@@ -46,16 +58,17 @@ export class PipInstaller extends BaseInstaller {
      * @param requirement The requirement to install
      * @returns The status of the installation
      */
-    async install(requirement) {
+    async install(requirement, options) {
         try {
-            const status = await this.checkInstallation(requirement);
+            const status = await this.checkInstallation(requirement, options);
             if (status.installed) {
                 return status;
             }
+            const pipCmd = this.getPipCommand(options);
             // If no registry is specified, use standard pip installation
             if (!requirement.registry) {
                 // Standard pip installation
-                const { stderr } = await this.execPromise(`pip install ${requirement.name}==${requirement.version}`);
+                const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
                 if (stderr && stderr.toLowerCase().includes('error')) {
                     throw new Error(stderr);
                 }
@@ -67,7 +80,7 @@ export class PipInstaller extends BaseInstaller {
                     const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
                     packageSource = result.resolvedPath;
                     // Install from the downloaded wheel or tar.gz file
-                    const { stderr } = await this.execPromise(`pip install "${packageSource}"`);
+                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }
@@ -75,7 +88,7 @@ export class PipInstaller extends BaseInstaller {
                 else if (requirement.registry.artifacts) {
                     const registryUrl = requirement.registry.artifacts.registryUrl;
                     // Install using the custom index URL
-                    const { stderr } = await this.execPromise(`pip install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`);
+                    const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }
@@ -83,7 +96,7 @@ export class PipInstaller extends BaseInstaller {
                 else if (requirement.registry.local) {
                     packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
                     // Install from the local path
-                    const { stderr } = await this.execPromise(`pip install "${packageSource}"`);
+                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }

package/dist/core/installers/RequirementInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../types.js';
 /**
  * Interface for requirement installers.
  * Implementations should handle specific requirement types.
@@ -10,18 +10,19 @@ export interface RequirementInstaller {
      * @returns True if this installer can handle the requirement
      */
     canHandle(requirement: RequirementConfig): boolean;
+    supportCheckUpdates(): boolean;
     /**
      * Install the requirement
      * @param requirement The requirement to install
      * @returns The status of the installation
      */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Check if the requirement is already installed
      * @param requirement The requirement to check
      * @returns The status of the requirement
      */
-    checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Check if updates are available for the requirement
      * @param requirement The requirement to check