imcp 0.0.14 → 0.0.16

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

@@ -1,28 +1,21 @@
-import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { ConfigurationProvider } from '../../ConfigurationProvider.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
 import {
     ServerOperationResult,
     OperationStatus,
-    MCPServerStatus,
-    RequirementStatus,
     ServerInstallOptions,
-    FeedConfiguration,
-    McpConfig
+    McpConfig,
+    RequirementStatus
 } from '../../types.js';
-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 * as path from 'path';
 import { Logger } from '../../../utils/logger.js';
-import { getPythonPackagePath, getSystemPythonPackageDirectory } from '../../../utils/osUtils.js';
-
-const execAsync = promisify(exec); // Moved promisify here for reuse
+import { ClientInstallerFactory } from './ClientInstallerFactory.js';
 
+/**
+ * Main client installer class that orchestrates client installation process
+ * Handles requirements checking and delegates to specific client installers
+ */
 export class ClientInstaller {
     private configProvider: ConfigurationProvider;
-    private operationStatuses: Map<string, OperationStatus>;
 
     constructor(
         private categoryName: string,
@@ -30,109 +23,89 @@ export class ClientInstaller {
         private clients: string[]
     ) {
         this.configProvider = ConfigurationProvider.getInstance();
-        this.operationStatuses = new Map();
     }
 
+    /**
+     * Generate a unique operation ID for tracking installations
+     */
     private generateOperationId(): string {
         return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
 
-    private async getNpmPath(): Promise<string> {
-        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"');
-
-            // Extract the directory from the full path (removing npm.cmd)
-            const npmPath = stdout.trim().replace(/\\npm\.cmd$/, '');
-            return npmPath;
-        } catch (error) {
-            console.error('Error getting npm path:', error);
-            // Return a default path if the command fails
-            return 'C:\\Program Files\\nodejs';
-        }
-    }
-
-
     /**
-     * Check if a command is available on the system
-     * @param command The command to check
-     * @returns True if the command is available, false otherwise
+     * Check if server requirements are ready
+     * Waits for requirements to be ready with timeout
      */
-    private async 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';
+    private async checkRequirements(operationId: string, clientName: string, options: ServerInstallOptions): Promise<boolean> {
+        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
 
-                    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`;
+        if (!requirementsReady) {
+            const pendingStatus: OperationStatus = {
+                status: 'pending',
+                type: 'install',
+                target: 'server',
+                message: `Waiting for requirements to be ready for client: ${clientName}`,
+                operationId
+            };
 
-                            try {
-                                await execAsync(`test -d "${userVSCodePath}"`);
-                                return true;
-                            } catch (error) {
-                                return false;
-                            }
-                        }
-                        return false;
-                    }
-                }
-            }
+            await this.configProvider.updateServerOperationStatus(
+                this.categoryName,
+                this.serverName,
+                clientName,
+                pendingStatus
+            );
+
+            // Set up periodic checking with timeout
+            const startTime = Date.now();
+            const timeoutMs = 5 * 60 * 1000; // 5 minutes
+            const intervalMs = 5 * 1000; // 5 seconds
 
-            // For Windows, use where command
-            if (process.platform === 'win32') {
-                await execAsync(`where ${command}`);
-                return true;
+            while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
+                await new Promise(resolve => setTimeout(resolve, intervalMs));
+                requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
             }
+        }
 
-            // For all other cases (Unix-like systems), use which command
-            await execAsync(`which ${command}`);
-            return true;
-        } catch (error) {
-            return false;
+        var requirementsStatus: RequirementStatus[] = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
+
+        // Find first non-empty npmPath from requirements status
+        const npmPathRequirement = requirementsStatus.find(status => status.npmPath && status.npmPath.length > 0);
+        if (npmPathRequirement && npmPathRequirement.npmPath) {
+            options.settings = options.settings || {};
+            options.settings.npmPath = npmPathRequirement.npmPath;
         }
+
+        return requirementsReady;
     }
 
-    // Modified to accept ServerInstallOptions
+    /**
+     * Install client with requirements checking
+     */
     private async installClient(clientName: string, options: ServerInstallOptions): Promise<OperationStatus> {
+        const operationId = this.generateOperationId();
+
         // Check if client is supported
-        if (!SUPPORTED_CLIENTS[clientName]) {
+        if (!ClientInstallerFactory.isClientSupported(clientName)) {
             return {
                 status: 'failed',
                 type: 'install',
                 target: 'server',
                 message: `Unsupported client: ${clientName}`,
-                operationId: this.generateOperationId()
+                operationId
             };
         }
 
         // Create initial operation status
-        const operationId = this.generateOperationId();
         const initialStatus: OperationStatus = {
             status: 'pending',
             type: 'install',
             target: 'server',
             message: `Initializing installation for client: ${clientName}`,
-            operationId: operationId
+            operationId
         };
 
+        this.processInstallation(clientName, operationId, options);
+
         // Update server status with initial client installation status
         await this.configProvider.updateServerOperationStatus(
             this.categoryName,
@@ -140,73 +113,41 @@ export class ClientInstaller {
             clientName,
             initialStatus
         );
-
-        // Start the asynchronous installation process without awaiting it
-        // Pass options down
-        this.processInstallation(clientName, operationId, options);
-
-        // Return the initial status immediately
         return initialStatus;
     }
 
-    // Modified to accept ServerInstallOptions
     private async processInstallation(clientName: string, operationId: string, options: ServerInstallOptions): Promise<void> {
         try {
-            await ExtensionInstaller.installExtension(clientName);
-
-            // Check requirements before installation
-            let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
-
-            // If requirements are not ready, periodically check with timeout
+            // Check requirements
+            const requirementsReady = await this.checkRequirements(operationId, clientName, options);
             if (!requirementsReady) {
-                const pendingStatus: OperationStatus = {
-                    status: 'pending',
+                const failedStatus: OperationStatus = {
+                    status: 'failed',
                     type: 'install',
                     target: 'server',
-                    message: `Waiting for requirements to be ready for client: ${clientName}`,
-                    operationId: operationId
+                    message: `Requirements not ready for client: ${clientName} after timeout`,
+                    operationId
                 };
 
-                // Update status to pending with reference to configProvider
                 await this.configProvider.updateServerOperationStatus(
                     this.categoryName,
                     this.serverName,
                     clientName,
-                    pendingStatus
+                    failedStatus
                 );
+                return;
+            }
 
-                // Set up periodic checking with timeout
-                const startTime = Date.now();
-                const timeoutMs = 5 * 60 * 1000; // 5 minutes in milliseconds
-                const intervalMs = 5 * 1000; // 5 seconds in milliseconds
-
-                while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
-                    // Wait for the interval
-                    await new Promise(resolve => setTimeout(resolve, intervalMs));
-
-                    // Check again
-                    requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
-                }
-
-                // If still not ready after timeout, update status as failed and exit
-                if (!requirementsReady) {
-                    const failedStatus: OperationStatus = {
-                        status: 'failed',
-                        type: 'install',
-                        target: 'server',
-                        message: `Timed out waiting for requirements to be ready for client: ${clientName} after 5 minutes`,
-                        operationId: operationId
-                    };
+            // Create client-specific installer
+            const installer = ClientInstallerFactory.getInstaller(clientName);
 
-                    await this.configProvider.updateServerOperationStatus(
-                        this.categoryName,
-                        this.serverName,
-                        clientName,
-                        failedStatus
-                    );
+            if (!installer) {
+                throw new Error(`Failed to create installer for client: ${clientName}`);
+            }
 
-                    return; // Exit the installation process
-                }
+            const serverConfig = await this.configProvider.getServerMcpConfig(this.categoryName, this.serverName);
+            if (!serverConfig) {
+                throw new Error(`Server configuration not found for category: ${this.categoryName}, server: ${this.serverName}`);
             }
 
             // If we've reached here, requirements are ready - update status to in-progress
@@ -224,101 +165,25 @@ export class ClientInstaller {
                 clientName,
                 inProgressStatus
             );
+            // Install client
+            const status = await installer.install(serverConfig, options);
+            await this.configProvider.updateServerOperationStatus(
+                this.categoryName,
+                this.serverName,
+                clientName,
+                status
+            );
 
-            // Get feed configuration for the server
-            const feedConfiguration = await this.configProvider.getFeedConfiguration(this.categoryName);
-            if (!feedConfiguration) {
-                const errorStatus: OperationStatus = {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: `Failed to get feed configuration for category: ${this.categoryName}`,
-                    operationId: operationId
-                };
-                await this.configProvider.updateServerOperationStatus(
-                    this.categoryName,
-                    this.serverName,
-                    clientName,
-                    errorStatus
-                );
-                return;
-            }
-
-            // Find the server config in the feed configuration
-            const serverConfig = feedConfiguration.mcpServers.find(s => s.name === this.serverName);
-            if (!serverConfig) {
-                const errorStatus: OperationStatus = {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: `Server ${this.serverName} not found in feed configuration`,
-                    operationId: operationId
-                };
-                await this.configProvider.updateServerOperationStatus(
-                    this.categoryName,
-                    this.serverName,
-                    clientName,
-                    errorStatus
-                );
-                return;
-            }
-
-            try {
-                // Install extension if available
-                if (SUPPORTED_CLIENTS[clientName]?.extension) {
-                    const extensionResult = await ExtensionInstaller.installExtension(clientName);
-                    if (!extensionResult) {
-                        Logger.debug(`Failed to install extension for client ${clientName}`);
-                    }
-                }
-
-                // Install client-specific configuration, passing options down
-                const result = await this.installClientConfig(clientName, options, serverConfig, feedConfiguration);
-
-                const finalStatus: OperationStatus = {
-                    status: result.success ? 'completed' : 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: result.message || `Installation for client ${clientName}: ${result.success ? 'successful' : 'failed'}`,
-                    operationId: operationId,
-                    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: OperationStatus = {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: `Failed to install client: ${clientName}. Error: ${error instanceof Error ? error.message : String(error)}`,
-                    operationId: operationId,
-                    error: error instanceof Error ? error.message : String(error)
-                };
-
-                await this.configProvider.updateServerOperationStatus(
-                    this.categoryName,
-                    this.serverName,
-                    clientName,
-                    errorStatus
-                );
+            if (status.status === 'completed') {
+                await this.configProvider.reloadClientMCPSettings();
             }
         } catch (error) {
             const errorStatus: OperationStatus = {
                 status: 'failed',
                 type: 'install',
                 target: 'server',
-                message: `Unexpected error in installation process for client: ${clientName}. Error: ${error instanceof Error ? error.message : String(error)}`,
-                operationId: operationId,
+                message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
                 error: error instanceof Error ? error.message : String(error)
             };
 
@@ -331,402 +196,26 @@ export class ClientInstaller {
         }
     }
 
-    // Modified to accept ServerInstallOptions
-    private async installClientConfig(
-        clientName: string,
-        options: ServerInstallOptions, // Use options directly
-        serverConfig: McpConfig,
-        feedConfig: FeedConfiguration
-    ): Promise<{ success: boolean; message: string }> {
-        try {
-            if (!SUPPORTED_CLIENTS[clientName]) {
-                Logger.debug(`Client ${clientName} is not supported.`);
-                return { success: false, message: `Unsupported client: ${clientName}` };
-            }
-
-            const clientSettings = SUPPORTED_CLIENTS[clientName];
-
-            // Get both setting paths for VS Code and VS Code Insiders
-            const regularSettingPath = clientSettings.codeSettingPath;
-            const insidersSettingPath = clientSettings.codeInsiderSettingPath;
-
-            Logger.debug(`Starting installation of ${this.serverName} for client ${clientName}`);
-            Logger.debug(`VS Code settings path configured as: ${regularSettingPath}`);
-            Logger.debug(`VS Code Insiders settings path configured as: ${insidersSettingPath}`);
-
-            // Check if VS Code and VS Code Insiders are installed
-            const isVSCodeInstalled = await this.isCommandAvailable('code');
-            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');
-
-            // If neither is installed, we can't proceed
-            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
-                Logger.debug('No VS Code installations detected on system. Cannot update settings.');
-                return {
-                    success: false,
-                    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.`
-                };
-            }
-
-            // --- Start of new logic ---
-
-            // Clone the base installation configuration to avoid modifying the original serverConfig
-            const installConfig = JSON.parse(JSON.stringify(serverConfig.installation));
-            installConfig.mode = serverConfig.mode
-            const pythonEnv = options.settings?.pythonEnv;
-            let pythonDir: string | null = null;
-
-            // 1. Determine which args to use and resolve npm paths
-            let finalArgs: string[] = [];
-            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: string) => 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}'));
-                    }
-                }
-            }
-
-            // 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: Record<string, string> = {};
-            for (const [key, config] of Object.entries(baseEnv)) {
-                const envConfig = config as any; // 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 as string).replace('${BROWSER_PATH}', browserPath)] as [string, string];
-                    } catch (error) {
-                        Logger.error(`Failed to get system browser path for env var ${key}:`, error);
-                        return [key, value] as [string, string];
-                    }
-                });
-
-            // 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;
-            let errorMessages: string[] = [];
-
-            // Update client-specific settings for both VS Code and VS Code Insiders
-            if (clientName === 'MSRooCode' || clientName === 'Cline') {
-                // Update VS Code settings if VS Code is installed
-                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)`);
-                    } catch (error) {
-                        const errorMsg = `Error updating VS Code settings: ${error instanceof Error ? error.message : String(error)}`;
-                        errorMessages.push(errorMsg);
-                        console.error(errorMsg);
-                    }
-                }
-
-                // Update VS Code Insiders settings if VS Code Insiders is installed
-                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)`);
-                    } catch (error) {
-                        const errorMsg = `Error updating VS Code Insiders settings: ${error instanceof Error ? error.message : String(error)}`;
-                        errorMessages.push(errorMsg);
-                        console.error(errorMsg);
-                    }
-                }
-            } else if (clientName === 'GithubCopilot') {
-                // Update VS Code settings if VS Code is installed
-                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)`);
-                    } catch (error) {
-                        const errorMsg = `Error updating VS Code settings: ${error instanceof Error ? error.message : String(error)}`;
-                        errorMessages.push(errorMsg);
-                        console.error(errorMsg);
-                    }
-                }
-
-                // Update VS Code Insiders settings if VS Code Insiders is installed
-                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)`);
-                    } catch (error) {
-                        const errorMsg = `Error updating VS Code Insiders settings: ${error instanceof Error ? error.message : String(error)}`;
-                        errorMessages.push(errorMsg);
-                        console.error(errorMsg);
-                    }
-                }
-            } else {
-                Logger.debug(`No implementation exists for updating settings for client: ${clientName}`);
-                return {
-                    success: false,
-                    message: `Client ${clientName} is supported but no implementation exists for updating its settings`
-                };
-            }
-
-            // Determine overall success status and message
-            const overallSuccess = regularSuccess || insidersSuccess;
-            let message = '';
-
-            if (overallSuccess) {
-                const successDetails = [];
-                if (regularSuccess) successDetails.push('VS Code');
-                if (insidersSuccess) successDetails.push('VS Code Insiders');
-
-                // Create a more compact success message with specific paths
-                const pathDetails = [];
-                if (regularSuccess) {
-                    pathDetails.push(`\n[VS Code]: ${regularSettingPath}`);
-                }
-                if (insidersSuccess) {
-                    pathDetails.push(`\n[VS Code Insiders]: ${insidersSettingPath}`);
-                }
-                message = `Successfully installed ${this.serverName} for client: ${clientName}. ${pathDetails.join(' ')}`;
-
-                // Add partial failure information if applicable
-                if (errorMessages.length > 0) {
-                    message += `\nHowever, some errors occurred:\n${errorMessages.join('\n- ')}`;
-                }
-                Logger.debug(`Installation complete: ${message}`);
-            } else {
-                // Create a more detailed failure message that includes the detection results
-                const detectionInfo = [];
-                if (!isVSCodeInstalled) detectionInfo.push('VS Code not detected');
-                if (!isVSCodeInsidersInstalled) detectionInfo.push('VS Code Insiders not detected');
-
-                if (errorMessages.length > 0) {
-                    message = `Failed to install ${this.serverName} for client: ${clientName}.\nDetection status: [${detectionInfo.join(', ')}].\nErrors:\n- ${errorMessages.join('\n- ')}`;
-                } else {
-                    message = `Failed to install ${this.serverName} for client: ${clientName}.\nDetection status: [${detectionInfo.join(', ')}]`;
-                }
-                console.error(`Installation failed: ${message}`);
-            }
-
-            return {
-                success: overallSuccess,
-                message: message
-            };
-        } catch (error) {
-            const errorMsg = `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`;
-            console.error(errorMsg);
-            return {
-                success: false,
-                message: errorMsg
-            };
-        }
-    }
-
-    private async updateClineOrMSRooSettings(
-        settingPath: string,
-        serverName: string,
-        installConfig: any, // Use the processed installConfig
-        clientName: string
-    ): Promise<void> {
-        // Read the Cline/MSRoo settings file
-        const settings = await readJsonFile(settingPath, true);
-
-        // Initialize mcpServers section if it doesn't exist
-        if (!settings.mcpServers) {
-            settings.mcpServers = {};
-        }
-
-        if (installConfig.mode === 'stdio') {
-            // Special handling for Windows when command is npx for Cline and MSROO clients
-            // Use a copy to avoid modifying the passed installConfig directly if needed elsewhere
-            const serverConfigForClient = { ...installConfig };
-            if (process.platform === 'win32' &&
-                serverConfigForClient.command === 'npx' &&
-                (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
-                // Update command to cmd
-                serverConfigForClient.command = 'cmd';
-
-                // Add /c and npx at the beginning of args
-                serverConfigForClient.args = ['/c', 'npx', ...serverConfigForClient.args];
-
-                // Add APPDATA environment variable pointing to npm directory
-                if (!serverConfigForClient.env) {
-                    serverConfigForClient.env = {};
-                }
-
-                // Dynamically get npm path and set APPDATA to it
-                const npmPath = await this.getNpmPath();
-                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: string) =>
-                    typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
-                );
-            }
-
-            // Add or update the server configuration
-            settings.mcpServers[serverName] = {
-                command: serverConfigForClient.command,
-                args: serverConfigForClient.args,
-                env: serverConfigForClient.env,
-                autoApprove: [],
-                disabled: false,
-                alwaysAllow: []
-            };
-            Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcpServers[serverName])}`);
-        } else if (installConfig.mode === 'sse') {
-            // Handle SSE mode for Cline and MSRoo clients
-            settings.mcpServers[serverName] = {
-                type: 'sse',
-                url: installConfig.url
-            };
-        }
-
-        // Write the updated settings back to the file
-        await writeJsonFile(settingPath, settings);
-    }
-
-    private async updateGithubCopilotSettings(
-        settingPath: string,
-        serverName: string,
-        installConfig: any // Use the processed installConfig
-    ): Promise<void> {
-        // Read the VS Code settings.json file
-        const settings = await readJsonFile(settingPath, true);
-
-        // Initialize the mcp section if it doesn't exist
-        if (!settings.mcp) {
-            settings.mcp = {
-                servers: {},
-                inputs: []
-            };
-        }
-
-        if (!settings.mcp.servers) {
-            settings.mcp.servers = {};
-        }
-
-        // Use a copy to avoid modifying the passed installConfig directly
-        const serverConfigForClient = { ...installConfig };
-
-        if (installConfig.mode === 'stdio') {
-            if (serverConfigForClient.args) {
-                serverConfigForClient.args = serverConfigForClient.args.map((arg: string) =>
-                    typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
-                );
-            }
-
-            // Add or update the server configuration
-            settings.mcp.servers[serverName] = {
-                command: serverConfigForClient.command,
-                args: serverConfigForClient.args,
-                env: serverConfigForClient.env
-            };
-            Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcp.servers[serverName])}`);
-        }
-        else if (installConfig.mode === 'sse') {
-            // Handle SSE mode for Github Copilot
-            settings.mcp.servers[serverName] = {
-                type: 'sse',
-                url: installConfig.url
-            };
-        }
-
-        // Write the updated settings back to the file
-        await writeJsonFile(settingPath, settings);
-    }
-
+    /**
+     * Install all specified clients
+     */
     async install(options: ServerInstallOptions): Promise<ServerOperationResult> {
         const initialStatuses: OperationStatus[] = [];
 
-        // Start installation for each client asynchronously and collect initial statuses
-        // Pass options down to installClient
+        // Start installation for each client asynchronously
         const installPromises = this.clients.map(async (clientName) => {
-            const initialStatus = await this.installClient(clientName, options);
-            initialStatuses.push(initialStatus);
-            return initialStatus;
+            const status = await this.installClient(clientName, options);
+            initialStatuses.push(status);
+            return status;
         });
 
-        // Wait for all initial statuses (but actual installation continues asynchronously)
+        // Wait for all installations to complete
         await Promise.all(installPromises);
 
-        // Return initial result showing installations have been initiated
+        // Return result
         return {
             success: true,
-            message: 'Client installations initiated successfully',
+            message: 'Client installations completed',
             status: initialStatuses
         };
     }