imcp 0.0.14 → 0.0.16

package/src/core/installers/clients/ClientInstallerFactory.ts

@@ -0,0 +1,43 @@
+import { MSRooCodeInstaller } from './MSRooCodeInstaller.js';
+import { ClineInstaller } from './ClineInstaller.js';
+import { GithubCopilotInstaller } from './GithubCopilotInstaller.js';
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+
+/**
+ * Factory for creating client-specific installers
+ * Handles creation of appropriate installer based on client type
+ */
+export class ClientInstallerFactory {
+    private static readonly installerMap: Record<string, new () => BaseClientInstaller> = {
+        [Object.keys(SUPPORTED_CLIENTS)[0]]: MSRooCodeInstaller,
+        [Object.keys(SUPPORTED_CLIENTS)[1]]: ClineInstaller,
+        [Object.keys(SUPPORTED_CLIENTS)[2]]: GithubCopilotInstaller
+    };
+
+    /**
+     * Get a client installer instance based on client type
+     * @param clientName Name of the client to get installer for
+     * @returns Client-specific installer instance or undefined if client not supported
+     */
+    static getInstaller(
+        clientName: string
+    ): BaseClientInstaller | undefined {
+        // Check if client is supported
+        if (!SUPPORTED_CLIENTS[clientName]) {
+            return undefined;
+        }
+
+        const InstallerClass = this.installerMap[clientName as keyof typeof this.installerMap];
+        return InstallerClass ? new InstallerClass() : undefined;
+    }
+
+    /**
+     * Check if a client is supported
+     * @param clientName Name of the client to check
+     * @returns True if client is supported, false otherwise
+     */
+    static isClientSupported(clientName: string): boolean {
+        return !!SUPPORTED_CLIENTS[clientName];
+    }
+}

package/src/core/installers/clients/ClineInstaller.ts

@@ -0,0 +1,135 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { Logger } from '../../../utils/logger.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+
+/**
+ * Cline client installer implementation
+ * Handles installation of Cline client including extension installation and settings configuration
+ */
+export class ClineInstaller extends BaseClientInstaller {
+    /**
+     * Install Cline client
+     * @param options Installation options including environment variables and arguments
+     */
+    async install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus> {
+        const operationId = this.generateOperationId();
+        
+        try {
+            // Check if VS Code or VS Code Insiders is installed
+            const isVSCodeInstalled = await isCommandAvailable('code');
+            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+
+            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
+                    operationId
+                };
+            }
+
+            // Install extension
+            const extensionResult = await ExtensionInstaller.installExtension('Cline');
+            if (!extensionResult) {
+                Logger.debug('Failed to install Cline extension');
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Failed to install Cline extension',
+                    operationId
+                };
+            }
+
+
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+            // Track success for both VS Code variants
+            const results: Array<{ success: boolean; path: string; error?: string }> = [];
+
+            // Update settings for VS Code if installed
+            if (isVSCodeInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['Cline'].codeSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                } catch (error) {
+                    results.push({ 
+                        success: false, 
+                        path: SUPPORTED_CLIENTS['Cline'].codeSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+
+            // Update settings for VS Code Insiders if installed
+            if (isVSCodeInsidersInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['Cline'].codeInsiderSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                } catch (error) {
+                    results.push({ 
+                        success: false, 
+                        path: SUPPORTED_CLIENTS['Cline'].codeInsiderSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess 
+                    ? `Successfully installed Cline client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install Cline client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        } catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing Cline client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+
+    /**
+     * Set up Cline client settings
+     * Updates VS Code settings with MCP server configuration
+     */
+    async setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void> {
+        // Read existing settings
+        const settings = await readJsonFile(settingPath, true);
+
+        // Initialize settings with client-specific structure
+        this.initializeSettings(settings);
+
+        // Handle different modes
+        if (installConfig.mode === 'stdio') {
+            // Process config for Windows NPX if needed
+            const finalConfig = await this.handleWindowsNpx(installConfig);
+
+            await this.handleStdioMode(settings, serverName, finalConfig);
+        } else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}

package/src/core/installers/clients/GithubCopilotInstaller.ts

@@ -0,0 +1,179 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { Logger } from '../../../utils/logger.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+
+/**
+ * Github Copilot client installer implementation
+ * Handles installation of Github Copilot client including extension installation and settings configuration
+ */
+export class GithubCopilotInstaller extends BaseClientInstaller {
+
+    /**
+     * Install Github Copilot client
+     * @param options Installation options including environment variables and arguments
+     */
+    async install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus> {
+        const operationId = this.generateOperationId();
+
+        try {
+            // Check if VS Code or VS Code Insiders is installed
+            const isVSCodeInstalled = await isCommandAvailable('code');
+            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+
+            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
+                    operationId
+                };
+            }
+
+            // Install extension
+            const extensionResult = await ExtensionInstaller.installExtension('GithubCopilot');
+            if (!extensionResult) {
+                Logger.debug('Failed to install Github Copilot extension');
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Failed to install Github Copilot extension',
+                    operationId
+                };
+            }
+
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+
+            // Track success for both VS Code variants
+            const results: Array<{ success: boolean; path: string; error?: string }> = [];
+
+            // Update settings for VS Code if installed
+            if (isVSCodeInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['GithubCopilot'].codeSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['GithubCopilot'].codeSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+
+            // Update settings for VS Code Insiders if installed
+            if (isVSCodeInsidersInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['GithubCopilot'].codeInsiderSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['GithubCopilot'].codeInsiderSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess
+                    ? `Successfully installed Github Copilot client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install Github Copilot client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        } catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing Github Copilot client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+
+    /**
+     * Initialize settings with GithubCopilot-specific structure
+     * Overrides base method to provide custom initialization
+     */
+    protected initializeSettings(settings: any): void {
+        if (!settings.mcp) {
+            settings.mcp = {
+                servers: {},
+                inputs: []
+            };
+        }
+
+        if (!settings.mcp.servers) {
+            settings.mcp.servers = {};
+        }
+    }
+
+    /**
+     * Handle stdio mode configuration for GithubCopilot
+     * Overrides base method to provide custom stdio configuration
+     */
+    protected async handleStdioMode(settings: any, serverName: string, finalConfig: any): Promise<void> {
+        if (finalConfig.args) {
+            finalConfig.args = finalConfig.args.map((arg: string) =>
+                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+            );
+        }
+        settings.mcp.servers[serverName] = {
+            command: finalConfig.command,
+            args: finalConfig.args,
+            env: finalConfig.env
+        };
+    }
+
+    /**
+     * Handle SSE mode configuration for GithubCopilot
+     * Overrides base method to provide custom SSE configuration
+     */
+    protected handleSseMode(settings: any, serverName: string, installConfig: any): void {
+        settings.mcp.servers[serverName] = {
+            type: 'sse',
+            url: installConfig.url
+        };
+    }
+
+    /**
+     * Set up Github Copilot client settings
+     * Updates VS Code settings with MCP server configuration
+     * Note: GithubCopilot uses a different settings structure compared to other clients
+     */
+    async setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void> {
+        // Read existing settings
+        const settings = await readJsonFile(settingPath, true);
+
+        // Initialize settings with client-specific structure
+        this.initializeSettings(settings);
+
+        // Handle different modes
+        if (installConfig.mode === 'stdio') {
+            await this.handleStdioMode(settings, serverName, installConfig);
+        } else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}

package/src/core/installers/clients/MSRooCodeInstaller.ts

@@ -0,0 +1,133 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { Logger } from '../../../utils/logger.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+
+/**
+ * MSRooCode client installer implementation
+ */
+export class MSRooCodeInstaller extends BaseClientInstaller {
+    /**
+     * Install MSRooCode client
+     */
+    async install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus> {
+        const operationId = this.generateOperationId();
+
+        try {
+            // Check if VS Code or VS Code Insiders is installed
+            const isVSCodeInstalled = await isCommandAvailable('code');
+            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+
+            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
+                    operationId
+                };
+            }
+
+            // Install extension
+            const extensionResult = await ExtensionInstaller.installExtension('MSRooCode');
+            if (!extensionResult) {
+                Logger.debug('Failed to install MSRooCode extension');
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Failed to install MSRooCode extension',
+                    operationId
+                };
+            }
+
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+            installConfig.mode = serverConfig.mode;
+
+            // Track success for both VS Code variants
+            const results: Array<{ success: boolean; path: string; error?: string }> = [];
+
+            // Update settings for VS Code if installed
+            if (isVSCodeInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['MSRooCode'].codeSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['MSRooCode'].codeSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+
+            // Update settings for VS Code Insiders if installed
+            if (isVSCodeInsidersInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['MSRooCode'].codeInsiderSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['MSRooCode'].codeInsiderSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess
+                    ? `Successfully installed MSRooCode client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install MSRooCode client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        } catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing MSRooCode client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+
+    /**
+     * Set up MSRooCode client settings
+     */
+    async setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void> {
+        // Read existing settings
+        const settings = await readJsonFile(settingPath, true);
+
+        // Initialize settings with client-specific structure
+        this.initializeSettings(settings);
+
+        // Handle different modes
+        if (installConfig.mode === 'stdio') {
+            // Process config for Windows NPX if needed
+            const finalConfig = await this.handleWindowsNpx(installConfig);
+
+            await this.handleStdioMode(settings, serverName, finalConfig);
+        } else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}

package/src/core/installers/requirements/BaseInstaller.ts

@@ -1,8 +1,6 @@
 import { RequirementConfig, RequirementStatus, RegistryConfig, ServerInstallOptions } from '../../types.js';
 import path from 'path';
-import fs from 'fs/promises';
 import { SETTINGS_DIR } from '../../constants.js';
-import { extractZipFile } from '../../../utils/clientUtils.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 import { Logger } from '../../../utils/logger.js';
 
@@ -22,14 +20,24 @@ export abstract class BaseInstaller implements RequirementInstaller {
     abstract supportCheckUpdates(): boolean;
     abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Get the latest version available for the requirement.
+     * This method needs to be implemented by concrete installers.
+     * @param requirement The requirement to check.
+     * @param options Optional server install options.
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    abstract getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined>;
+
 
     /**
      * Check if updates are available for the requirement
      * @param requirement The requirement to check
      * @param currentStatus The current status of the requirement
+     * @param options Optional server install options.
      * @returns The status of the requirement with update information
      */
-    async checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus> {
+    async checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus, options?: ServerInstallOptions): Promise<RequirementStatus> {
         try {
             // If requirement is not installed, no need to check for updates
             if (!currentStatus.installed) {
@@ -41,23 +49,7 @@ export abstract class BaseInstaller implements RequirementInstaller {
                 return currentStatus;
             }
 
-            let latestVersion: string | undefined;
-
-            // Check based on registry type
-            if (requirement.registry?.githubRelease) {
-                latestVersion = await this.getGitHubLatestVersion(requirement.registry.githubRelease.repository);
-            } else {
-                // Use common practice based on requirement type
-                switch (requirement.type) {
-                    case 'npm':
-                        latestVersion = await this.getNpmLatestVersion(requirement.name);
-                        break;
-                    case 'pip':
-                        latestVersion = await this.getPipLatestVersion(requirement.name);
-                        break;
-                    // Add other types as needed
-                }
-            }
+            const latestVersion = await this.getLatestVersion(requirement, options);
 
             // If we found a latest version and it's different from current
             if (latestVersion && latestVersion !== currentStatus.version) {
@@ -78,123 +70,8 @@ export abstract class BaseInstaller implements RequirementInstaller {
 
         } catch (error) {
             // Don't update status on error, just log it
-            console.warn(`Error checking for updates for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            Logger.log(`Error checking for updates for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
             return currentStatus;
         }
     }
-
-    /**
-     * Helper to handle artifact registry downloads
-     * @param requirement The requirement configuration
-     * @param registry The artifacts registry configuration
-     * @returns The registry URL
-     */
-    protected async handleArtifactsRegistry(
-        requirement: RequirementConfig,
-        registry: RegistryConfig['artifacts']
-    ): Promise<string> {
-        if (!registry) {
-            throw new Error('Artifacts registry configuration is required');
-        }
-
-        const { registryUrl, assetName } = registry;
-
-        if (!registryUrl) {
-            throw new Error('Registry URL is required for artifacts downloads');
-        }
-
-        return registryUrl;
-    }
-
-    /**
-     * Helper to handle local path registry
-     * @param requirement The requirement configuration
-     * @param registry The local registry configuration
-     * @returns The local path or extracted asset path
-     */
-    protected async handleLocalRegistry(
-        requirement: RequirementConfig,
-        registry: RegistryConfig['local']
-    ): Promise<string> {
-        if (!registry) {
-            throw new Error('Local registry configuration is required');
-        }
-
-        const { localPath, assetName } = registry;
-
-        if (!localPath) {
-            throw new Error('Local path is required for local registry');
-        }
-
-        // Verify the local path exists
-        try {
-            await fs.access(localPath);
-        } catch (error) {
-            throw new Error(`Local path ${localPath} does not exist or is not accessible`);
-        }
-
-        // If the path is a zip file and assetName is specified, extract it
-        if (localPath.endsWith('.zip') && assetName) {
-            const extractDir = path.join(this.downloadsDir, path.basename(localPath, '.zip'));
-            await fs.mkdir(extractDir, { recursive: true });
-
-            // Extract the zip file
-            await extractZipFile(localPath, { dir: extractDir });
-
-            // Find the asset in the extracted directory
-            const assetPath = path.join(extractDir, assetName);
-            try {
-                await fs.access(assetPath);
-                return assetPath;
-            } catch (error) {
-                throw new Error(`Asset ${assetName} not found in extracted directory ${extractDir}`);
-            }
-        }
-
-        return localPath;
-    }
-
-    /**
-     * Get the latest version available for a GitHub repository
-     * @param repository The GitHub repository in format 'owner/repo'
-     * @returns The latest version or tag
-     */
-    protected async getGitHubLatestVersion(repository: string): Promise<string> {
-        try {
-            // Use GitHub CLI to get the latest release
-            const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
-            const latestTag = stdout.trim();
-
-            // Remove 'v' prefix if present
-            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
-        } catch (error) {
-            // If gh command fails, try to get the latest tag
-            const { stdout } = await this.execPromise(`git ls-remote --tags --refs https://github.com/${repository}.git | sort -t '/' -k 3 -V | tail -n 1 | awk -F/ '{print $3}'`);
-            let latestTag = stdout.trim();
-
-            // Remove 'v' prefix if present
-            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
-        }
-    }
-
-    /**
-     * Get the latest version available for an NPM package
-     * @param packageName The name of the NPM package
-     * @returns The latest version
-     */
-    protected async getNpmLatestVersion(packageName: string): Promise<string> {
-        const { stdout } = await this.execPromise(`npm view ${packageName} version`);
-        return stdout.trim();
-    }
-
-    /**
-     * Get the latest version available for a pip package
-     * @param packageName The name of the pip package
-     * @returns The latest version
-     */
-    protected async getPipLatestVersion(packageName: string, options?: ServerInstallOptions): Promise<string> {
-        const pythonCmd = options?.settings?.pythonEnv as string || 'python';
-        const { stdout } = await this.execPromise(`${pythonCmd} -m pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
-        return stdout.trim();
-    }
 }