imcp 0.1.1 → 0.1.2

package/dist/services/RequirementService.js

@@ -1,13 +1,21 @@
 import { createInstallerFactory } from '../core/installers/index.js';
 import { exec } from 'child_process';
 import util from 'util';
+import { configProvider, ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js';
+import { Logger } from '../utils/logger.js';
+import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
+import { InstallOperationManager } from '../core/loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../core/metadatas/recordingConstants.js';
+import { systemSettingsManager } from '../core/loaders/SystemSettingsManager.js';
 /**
  * Service responsible for managing requirements installation and status
  */
 export class RequirementService {
     static instance;
-    installerFactory = createInstallerFactory(util.promisify(exec));
-    constructor() { }
+    installerFactory;
+    constructor() {
+        this.installerFactory = createInstallerFactory(util.promisify(exec));
+    }
     /**
      * Get the singleton instance of RequirementService
      * @returns The RequirementService instance
@@ -18,76 +26,227 @@ export class RequirementService {
         }
         return RequirementService.instance;
     }
+    generateOperationId() {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
     /**
-     * Check the installation status of a requirement
-     * @param requirement The requirement to check
-     * @returns The installation status
+     * Checks and installs requirements for a server if needed.
+     * @param categoryName The category name.
+     * @param serverName The server name.
+     * @param options The installation options.
+     * @returns A failure result if requirements check fails, null if requirements are satisfied or installation started in background.
      */
-    async checkRequirementStatus(requirement, options) {
-        // Validate requirement
-        this.validateRequirement(requirement);
-        // Check the installation status
-        return await this.installerFactory.checkInstallation(requirement, options);
+    async checkAndInstallRequirements(categoryName, serverName, options) {
+        const recoder = InstallOperationManager.getInstance(categoryName, serverName);
+        return recoder.recording(async () => {
+            const configProvider = ConfigurationProvider.getInstance();
+            const feedConfig = await configProvider.getFeedConfiguration(categoryName);
+            if (!feedConfig) {
+                const errorMsg = 'Feed configuration not found';
+                // No need to record step here, recoder.recording will handle failure
+                return {
+                    success: false, message: errorMsg,
+                    status: [{ status: 'failed', type: 'install', target: 'server', message: errorMsg }]
+                };
+            }
+            const serverConfig = feedConfig.mcpServers.find((s) => s.name === serverName);
+            if (!serverConfig?.dependencies?.requirements || serverConfig.dependencies.requirements.length === 0) {
+                const msg = `No requirements for ${serverName} in category ${categoryName}`;
+                Logger.debug(msg);
+                await recoder.recordStep(RecordingConstants.STEP_CHECKING_REQUIREMENT_STATUS, 'completed', msg);
+                return null;
+            }
+            const ready = await recoder.recording(async () => {
+                await recoder.recordStep(RecordingConstants.STEP_CHECKING_REQUIREMENT_STATUS, 'in-progress', 'Checking status of all requirements.');
+                const requirementStatuses = await Promise.all(serverConfig.dependencies.requirements.map(async (req) => {
+                    const reqConfig = feedConfig.requirements?.find((r) => r.name === req.name) || {
+                        name: req.name, version: req.version, type: 'npm' // Default to npm if not fully defined
+                    };
+                    return await this.installerFactory.checkInstallation(reqConfig, options);
+                }));
+                const requirementsReady = await configProvider.isRequirementsReady(categoryName, serverName);
+                for (const status of requirementStatuses) {
+                    if (status.installed && !requirementsReady) {
+                        await configProvider.updateRequirementStatus(categoryName, status.name, { ...status, installed: true });
+                    }
+                    else if (!status.installed && requirementsReady) {
+                        await configProvider.updateRequirementStatus(categoryName, status.name, { ...status, installed: false });
+                    }
+                }
+                return requirementStatuses.every(status => status.installed);
+            }, {
+                stepName: RecordingConstants.STEP_CHECKING_REQUIREMENT_STATUS,
+                inProgressMessage: `Checking status of all requirements for ${serverName}`,
+                endMessage: (ready) => ready ? `Requirements for ${serverName} in ${categoryName} are already installed.` : 'Requirements check completed. Some requirements need installation.',
+            });
+            // If requirements are already installed, return null
+            if (ready)
+                return null;
+            const sortedRequirements = [...serverConfig.dependencies.requirements].sort((a, b) => {
+                const orderA = a.order ?? Infinity;
+                const orderB = b.order ?? Infinity;
+                return orderA - orderB;
+            });
+            // Use recordingAsync for the background task
+            recoder.recordingAsync(() => this.installRequirementsInBackground(categoryName, serverName, feedConfig, sortedRequirements, options, recoder), {
+                stepName: RecordingConstants.STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND,
+                inProgressMessage: 'Starting background installation of requirements.',
+                endMessage: () => 'Background installation of requirements completed.',
+                onError: (err) => {
+                    const errorMsg = `Error in background requirement installations for ${serverName} in ${categoryName}: ${err instanceof Error ? err.message : String(err)}`;
+                    Logger.error(errorMsg);
+                    return errorMsg; // This message will be recorded for the 'failed' step
+                }
+            });
+            // The main operation returns null as installation is happening in background
+            return null;
+        }, {
+            stepName: RecordingConstants.STEP_CHECK_AND_INSTALL_REQUIREMENTS,
+            inProgressMessage: `Checking and installing requirements for ${serverName}`,
+            endMessage: (result) => result?.success === false ? `Requirement check/install failed: ${result.message}` : `Requirement check and install process for ${serverName} completed.`,
+            onResult: (result) => result === null || result.success !== false // Success if null (bg install) or result.success is not false
+        });
     }
     /**
-     * Check if updates are available for a requirement
-     * @param requirement The requirement to check for updates
-     * @returns Updated status with available updates information
+     * Installs requirements in background without blocking the main thread.
+     * Requirements with the same order are installed in parallel.
+     * @param categoryName The category name.
+     * @param feedConfig The feed configuration.
+     * @param sortedRequirements Array of requirements sorted by order.
+     * @param options The installation options.
      */
-    async checkRequirementForUpdates(requirement, currentStatus) {
-        // Validate requirement
-        this.validateRequirement(requirement);
-        // Get current status
-        // Check for updates using the appropriate installer
-        const installer = this.installerFactory.getInstaller(requirement);
-        if (!installer || !installer.supportCheckUpdates()) {
-            return currentStatus;
+    async installRequirementsInBackground(categoryName, serverName, feedConfig, sortedRequirements, options, recoder // Added recoder parameter
+    ) {
+        const configProvider = ConfigurationProvider.getInstance();
+        const requirementGroups = sortedRequirements.reduce((groups, req) => {
+            const order = req.order ?? Infinity;
+            if (!groups[order]) {
+                groups[order] = [];
+            }
+            groups[order].push(req);
+            return groups;
+        }, {});
+        const orderKeys = Object.keys(requirementGroups).map(Number).sort((a, b) => a - b);
+        for (const order of orderKeys) {
+            const group = requirementGroups[order];
+            await Promise.all(group.map(async (requirement) => {
+                const stepName = `InstallRequirement_${requirement.name}`;
+                return recoder.recording(async () => {
+                    let requirementConfig = feedConfig.requirements?.find((r) => r.name === requirement.name);
+                    if (!requirementConfig) {
+                        requirementConfig = { name: requirement.name, version: requirement.version, type: 'npm' }; // Default
+                        const warnMsg = `Requirement ${requirement.name} not found in feed's requirements definitions for category ${categoryName}. Using default config.`;
+                        Logger.warn(warnMsg);
+                        // This case is a "completion" of this specific step with a warning, not a failure.
+                        // The recording will mark it completed, and the message will be this warning.
+                        return { installed: true, message: warnMsg, type: requirementConfig.type, name: requirement.name, version: requirement.version };
+                    }
+                    let currentOptions = { ...options };
+                    const currentStatus = await configProvider.getRequirementStatus(categoryName, requirement.name);
+                    if (requirementConfig.type === 'pip' && currentStatus?.pythonEnv && !currentOptions?.settings?.pythonEnv) {
+                        currentOptions = {
+                            ...currentOptions,
+                            settings: { ...currentOptions?.settings, pythonEnv: currentStatus.pythonEnv }
+                        };
+                    }
+                    const installer = this.installerFactory.getInstaller(requirementConfig);
+                    if (!installer) {
+                        const errorMsg = `No installer found for requirement type: ${requirementConfig.type}`;
+                        await this.updateRequirementFailureStatus(categoryName, requirement.name, requirementConfig.type, errorMsg);
+                        throw new Error(errorMsg); // Caught by recoder.recording
+                    }
+                    const operationId = this.generateOperationId();
+                    await this.updateRequirementProgressStatus(categoryName, requirement.name, requirementConfig.type, operationId);
+                    const installStatus = await installer.install(requirementConfig, recoder, currentOptions);
+                    const success = installStatus.installed;
+                    const message = success ? `Requirement ${requirement.name} installed successfully` : `Failed to install ${requirement.name}: ${installStatus.error || 'Unknown error'}`;
+                    await this.updateRequirementCompletionStatus(categoryName, requirement.name, installStatus, operationId);
+                    if (!success) {
+                        throw new Error(message); // Caught by recoder.recording
+                    }
+                    return { ...installStatus, message };
+                }, {
+                    stepName: stepName,
+                    inProgressMessage: `Starting installation of ${requirement.name}`,
+                    onResult: (status) => status.installed,
+                    endMessage: (status) => status.message // Use the message from the installStatus
+                });
+            }));
         }
-        // Pass pythonEnv from currentStatus if it exists for pip packages
-        const options = requirement.type === 'pip' && currentStatus.pythonEnv
-            ? { settings: { pythonEnv: currentStatus.pythonEnv } }
-            : undefined;
-        const status = await this.checkRequirementStatus(requirement, options);
-        return await installer.checkForUpdates(requirement, status);
     }
     /**
-     * Update a requirement to a new version
-     * @param requirement The requirement configuration
-     * @param updateVersion The version to update to
-     * @returns The updated requirement status
+     * Helper to update requirement status for failure case.
+     * @param categoryName The category name.
+     * @param requirementName The name of the requirement.
+     * @param requirementType The type of the requirement.
+     * @param errorMessage The error message.
      */
-    async updateRequirement(requirement, updateVersion, options) {
-        // Validate requirement
-        this.validateRequirement(requirement);
-        // Create an updated requirement with the new version
-        const updatedRequirement = {
-            ...requirement,
-            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
-        };
-        // Install the updated version
-        return await this.installerFactory.install(updatedRequirement, options);
+    async updateRequirementFailureStatus(categoryName, requirementName, requirementType, errorMessage) {
+        const configProvider = ConfigurationProvider.getInstance();
+        await configProvider.updateRequirementStatus(categoryName, requirementName, {
+            name: requirementName, type: requirementType, installed: false, error: errorMessage,
+            operationStatus: {
+                status: 'failed', type: 'install', target: 'requirement',
+                message: `Error installing requirement: ${errorMessage}`,
+                operationId: this.generateOperationId()
+            }
+        });
+    }
+    /**
+     * Helper to update requirement status for in-progress case.
+     * @param categoryName The category name.
+     * @param requirementName The name of the requirement.
+     * @param requirementType The type of the requirement.
+     * @param operationId The operation ID.
+     */
+    async updateRequirementProgressStatus(categoryName, requirementName, requirementType, operationId) {
+        const configProvider = ConfigurationProvider.getInstance();
+        await configProvider.updateRequirementStatus(categoryName, requirementName, {
+            name: requirementName, type: requirementType, installed: false, inProgress: true,
+            operationStatus: {
+                status: 'in-progress', type: 'install', target: 'requirement',
+                message: `Installing requirement: ${requirementName}`, operationId
+            }
+        });
+    }
+    /**
+     * Helper to update requirement status for completion case.
+     * @param categoryName The category name.
+     * @param requirementName The name of the requirement.
+     * @param installStatus The installation status.
+     * @param operationId The operation ID.
+     */
+    async updateRequirementCompletionStatus(categoryName, requirementName, installStatus, operationId) {
+        const configProvider = ConfigurationProvider.getInstance();
+        await configProvider.updateRequirementStatus(categoryName, requirementName, {
+            ...installStatus,
+            operationStatus: {
+                status: installStatus.installed ? 'completed' : 'failed',
+                type: 'install', target: 'requirement',
+                message: installStatus.installed
+                    ? `Requirement ${requirementName} installed successfully`
+                    : `Failed to install ${requirementName}`,
+                operationId
+            }
+        });
     }
     /**
-     * Validate a requirement configuration
-     * @param requirement The requirement to validate
-     * @throws Error if the requirement is invalid
+     * Validate a requirement configuration.
+     * @param requirement The requirement to validate.
+     * @throws Error if the requirement is invalid.
      */
     validateRequirement(requirement) {
-        // Ensure requirement has required fields
         if (!requirement.name) {
             throw new Error('Requirement name is required');
         }
         if (!requirement.type) {
             throw new Error('Requirement type is required');
         }
-        // For type 'other', registry must be specified
         if (requirement.type === 'other' && !requirement.registry) {
             throw new Error('Registry must be specified for requirement type "other"');
         }
-        // Validate registry configuration if provided
         if (requirement.registry) {
             const { githubRelease, artifacts } = requirement.registry;
-            // Validate GitHub release configuration
             if (githubRelease) {
                 if (!githubRelease.repository) {
                     throw new Error('Repository is required for GitHub release registry');
@@ -96,7 +255,6 @@ export class RequirementService {
                     throw new Error('Asset name is required for GitHub release registry');
                 }
             }
-            // Validate artifacts registry configuration
             if (artifacts) {
                 if (!artifacts.registryUrl) {
                     throw new Error('Registry URL is required for artifacts registry');
@@ -104,6 +262,287 @@ export class RequirementService {
             }
         }
     }
+    /**
+     * Check for updates to requirements for all server categories
+     * This method is called periodically to check for updates
+     */
+    async checkRequirementForUpdateAsync() {
+        const allCategories = await configProvider.getServerCategories();
+        allCategories.forEach(async (serverCategory) => {
+            // Start async check for requirement updates if one isn't already in progress
+            if (serverCategory && serverCategory.feedConfiguration && serverCategory.name) {
+                // Check if update is already in progress using the tracker
+                const shouldCheckForUpdates = await updateCheckTracker.startOperation(serverCategory.name);
+                if (shouldCheckForUpdates) {
+                    Logger.info(`Checking the status of requirements in ${serverCategory.name}`);
+                    this.checkRequirementsForUpdateInternal(serverCategory).catch(error => {
+                        // Ensure we mark the operation as complete on error
+                        if (serverCategory.name) {
+                            updateCheckTracker.endOperation(serverCategory.name)
+                                .catch(lockError => console.error(`Failed to mark update check as complete: ${lockError.message}`));
+                        }
+                        Logger.error(`Error checking requirements for updates: ${error.message}`);
+                    });
+                }
+                else {
+                    Logger.debug(`Update check already in progress for ${serverCategory.name}, skipping`);
+                }
+            }
+        });
+    }
+    /**
+     * Check for updates to requirements for a specific server category
+     * @param categoryName The name of the server category
+     * @param serverName The name of the server (optional)
+     */
+    async checkServerRequirementForUpdateAsync(categoryName, serverName) {
+        const serverCategory = await configProvider.getServerCategory(categoryName);
+        if (!serverCategory) {
+            Logger.error(`Server category ${categoryName} not found`);
+            return;
+        }
+        const shouldCheckForUpdates = await updateCheckTracker.startOperation(`${serverCategory.name}:${serverName}`);
+        if (shouldCheckForUpdates) {
+            this.checkRequirementsForUpdateInternal(serverCategory, serverName)
+                .then(() => {
+                // Mark the operation as complete
+                updateCheckTracker.endOperation(`${serverCategory.name}:${serverName}`)
+                    .catch(lockError => console.error(`Failed to mark update check as complete: ${lockError.message}`));
+            })
+                .catch(error => {
+                // Ensure we mark the operation as complete on error
+                updateCheckTracker.endOperation(`${serverCategory.name}:${serverName}`)
+                    .catch(lockError => console.error(`Failed to mark update check as complete: ${lockError.message}`));
+                Logger.error(`Error checking requirements for updates: ${error.message}`);
+            });
+        }
+    }
+    /**
+     * Check for updates to requirements for a server category
+     * @param serverCategory The server category to check
+     * @param serverName The name of the server (optional). When serverName is provided, check the requirement always
+     * @private
+     */
+    async checkRequirementsForUpdateInternal(serverCategory, serverName) {
+        if (!serverCategory.name || !serverCategory.feedConfiguration?.requirements?.length) {
+            return;
+        }
+        try {
+            for (const requirement of serverCategory.feedConfiguration.requirements) {
+                if (requirement.version.includes('latest')) {
+                    // Get current status if available
+                    const currentStatus = serverCategory.installationStatus?.requirementsStatus[requirement.name];
+                    if (!currentStatus)
+                        continue;
+                    let providedServerName = serverName;
+                    if (providedServerName) {
+                        // If serverName is provided, check if the requirement is associated with that server
+                        Logger.debug(`Checking whether requirement ${requirement.name} has update for server ${serverName}`);
+                        const serverConfig = serverCategory.feedConfiguration.mcpServers.find((s) => s.name === serverName);
+                        if (!serverConfig?.dependencies?.requirements?.some((r) => r.name == requirement.name)) {
+                            Logger.debug(`Requirement ${requirement.name} is not associated with server ${serverName}. Skipping update check.`);
+                            continue;
+                        }
+                    }
+                    else {
+                        providedServerName = serverCategory.feedConfiguration.mcpServers.find((s) => s.dependencies?.requirements?.some((r) => r.name == requirement.name))?.name;
+                    }
+                    if (!providedServerName) {
+                        // We need to find the server name for the requirement, if not able to find, skip as the requirement is not associated with any server
+                        Logger.debug(`No server using requirement ${requirement.name}. Skipping update check.`);
+                        continue;
+                    }
+                    // Check for updates
+                    const updatedStatus = await this.checkRequirementForUpdates(requirement, currentStatus, serverCategory.name, providedServerName);
+                    // If update information is found, update the configuration
+                    if (updatedStatus.availableUpdate && serverCategory.name) {
+                        await configProvider.updateRequirementStatus(serverCategory.name, requirement.name, updatedStatus);
+                        // Also update the in-memory status for immediate use
+                        if (serverCategory.installationStatus?.requirementsStatus) {
+                            serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
+                        }
+                    }
+                    currentStatus.lastCheckTime = new Date().toISOString();
+                    await configProvider.updateRequirementStatus(serverCategory.name, requirement.name, currentStatus);
+                    if (serverCategory.installationStatus?.requirementsStatus) {
+                        serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.error(`Error checking requirements for updates: ${error instanceof Error ? error.message : String(error)}`);
+            throw error; // Re-throw the error to be handled by the caller
+        }
+    }
+    /**
+     * Check the installation status of a requirement
+     * @param requirement The requirement to check
+     * @param options Optional installation options
+     * @returns The installation status
+     */
+    async checkRequirementStatus(requirement, options) {
+        this.validateRequirement(requirement);
+        return await this.installerFactory.checkInstallation(requirement, options);
+    }
+    /**
+     * Check if updates are available for a requirement
+     * @param requirement The requirement to check for updates
+     * @param currentStatus The current status of the requirement
+     * @param categoryName The category name
+     * @param serverName The server name (optional)
+     * @returns Updated status with available updates information
+     */
+    async checkRequirementForUpdates(requirement, currentStatus, categoryName, serverName) {
+        this.validateRequirement(requirement);
+        const installer = this.installerFactory.getInstaller(requirement);
+        if (!installer || !installer.supportCheckUpdates()) {
+            return currentStatus;
+        }
+        var systemSettings = await systemSettingsManager.getSystemSettings();
+        const options = requirement.type === 'pip'
+            ? { settings: { pythonEnv: systemSettings.pythonEnvs?.[`${categoryName}:${serverName}`] || systemSettings.pythonEnvs?.system || currentStatus.pythonEnv } }
+            : undefined;
+        const status = await this.checkRequirementStatus(requirement, options);
+        return await installer.checkForUpdates(requirement, status);
+    }
+    /**
+     * Process requirement updates specified in serverInstallOptions.
+     * All updates are processed in parallel for maximum efficiency.
+     * @param categoryName The category name.
+     * @param serverName The server name.
+     * @param options The installation options.
+     */
+    async processRequirementUpdates(categoryName, serverName, options) {
+        const operationKey = `requirement-updates-${categoryName}-${serverName}`;
+        const canProceed = await updateCheckTracker.startOperation(operationKey);
+        if (!canProceed) {
+            Logger.info(`Requirement updates for ${categoryName}/${serverName} already in progress, skipping`);
+            return;
+        }
+        const recoder = InstallOperationManager.getInstance(categoryName, serverName);
+        try {
+            await recoder.recording(async () => {
+                const configProvider = ConfigurationProvider.getInstance();
+                const feedConfig = await configProvider.getFeedConfiguration(categoryName);
+                if (!feedConfig) {
+                    const errorMsg = `Feed configuration not found for category: ${categoryName}`;
+                    Logger.error(errorMsg);
+                    throw new Error(errorMsg); // This will be caught by recoder.recording
+                }
+                const updatePromises = options.requirements?.map(async (reqToUpdate) => {
+                    const stepName = `${RecordingConstants.STEP_INSTALL_REQUIREMENT_PREFIX}: ${reqToUpdate.name}`;
+                    return recoder.recording(async () => {
+                        let reqConfig;
+                        let currentStatus;
+                        try {
+                            reqConfig = feedConfig.requirements?.find((r) => r.name === reqToUpdate.name);
+                            if (!reqConfig) {
+                                const errorMsg = `Requirement configuration not found for: ${reqToUpdate.name}`;
+                                Logger.error(errorMsg);
+                                await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                                    name: reqToUpdate.name, type: 'unknown', installed: false, inProgress: false,
+                                    error: errorMsg,
+                                    operationStatus: { status: 'failed', type: 'update', target: 'requirement', message: errorMsg }
+                                });
+                                throw new Error(errorMsg);
+                            }
+                            currentStatus = await configProvider.getRequirementStatus(categoryName, reqToUpdate.name);
+                            if (!currentStatus) {
+                                const errorMsg = `No current status found for requirement: ${reqToUpdate.name}`;
+                                Logger.error(errorMsg);
+                                await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                                    name: reqToUpdate.name, type: reqConfig.type, installed: false, inProgress: false,
+                                    error: errorMsg,
+                                    operationStatus: { status: 'failed', type: 'update', target: 'requirement', message: errorMsg }
+                                });
+                                throw new Error(errorMsg);
+                            }
+                            Logger.info(`Updating ${reqToUpdate.name} from ${currentStatus.version || 'unknown'} to ${reqToUpdate.version}`);
+                            await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                                ...currentStatus, name: reqToUpdate.name,
+                                type: currentStatus.type || reqConfig.type || 'unknown',
+                                installed: currentStatus.installed || false, inProgress: true,
+                                operationStatus: {
+                                    status: 'in-progress', type: 'update', target: 'requirement',
+                                    message: `Updating ${reqToUpdate.name} from ${currentStatus.version || 'unknown'} to ${reqToUpdate.version}`
+                                }
+                            });
+                            let currentOptions = { ...options };
+                            if (reqConfig.type === 'pip' && currentStatus.pythonEnv && !currentOptions?.settings?.pythonEnv) {
+                                currentOptions = {
+                                    ...currentOptions,
+                                    settings: { ...currentOptions?.settings, pythonEnv: currentStatus.pythonEnv }
+                                };
+                            }
+                            const updatedStatus = await this.updateRequirement(reqConfig, reqToUpdate.version, recoder, currentOptions);
+                            const successMessage = `Successfully updated ${reqToUpdate.name} to version ${reqToUpdate.version}`;
+                            const failureMessage = `Failed to update ${reqToUpdate.name} to version ${reqToUpdate.version}. Error: ${updatedStatus.error || 'Unknown'}`;
+                            await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                                ...updatedStatus, name: reqToUpdate.name,
+                                type: updatedStatus.type || currentStatus.type || reqConfig.type || 'unknown',
+                                installed: updatedStatus.installed, inProgress: false,
+                                operationStatus: {
+                                    status: updatedStatus.installed ? 'completed' : 'failed',
+                                    type: 'update', target: 'requirement',
+                                    message: updatedStatus.installed ? successMessage : failureMessage
+                                },
+                                availableUpdate: updatedStatus.installed ? undefined : currentStatus.availableUpdate
+                            });
+                            if (!updatedStatus.installed) {
+                                Logger.error(failureMessage);
+                                throw new Error(failureMessage);
+                            }
+                            Logger.info(successMessage);
+                            return updatedStatus;
+                        }
+                        catch (error) {
+                            const errorMsg = `Error updating requirement ${reqToUpdate.name}: ${error instanceof Error ? error.message : String(error)}`;
+                            Logger.error(errorMsg);
+                            await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                                name: reqToUpdate.name,
+                                type: reqConfig?.type || currentStatus?.type || 'unknown',
+                                installed: false, inProgress: false,
+                                error: error instanceof Error ? error.message : String(error),
+                                operationStatus: { status: 'failed', type: 'update', target: 'requirement', message: errorMsg }
+                            });
+                            throw error; // Re-throw to be handled by recoder.recording
+                        }
+                    }, {
+                        stepName: stepName,
+                        inProgressMessage: `Processing update for requirement ${reqToUpdate.name}`,
+                        onResult: (status) => status.installed, // status is the returned updatedStatus
+                    });
+                });
+                if (updatePromises) {
+                    await Promise.all(updatePromises);
+                }
+            }, {
+                stepName: RecordingConstants.STEP_PROCESS_REQUIREMENT_UPDATES,
+                inProgressMessage: `Starting to process requirement updates for ${serverName}`,
+                // If fn() succeeds, data is void. If fn() throws, recording() uses the error message.
+                endMessage: () => `Finished processing requirement updates for ${serverName}`
+            });
+        }
+        finally {
+            await updateCheckTracker.endOperation(operationKey);
+        }
+    }
+    /**
+ * Update a requirement to a new version
+ * @param requirement The requirement configuration
+ * @param updateVersion The version to update to
+ * @param options Optional installation options
+ * @returns The updated requirement status
+ */
+    async updateRequirement(requirement, updateVersion, recorder, options) {
+        this.validateRequirement(requirement);
+        const updatedRequirement = {
+            ...requirement,
+            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
+        };
+        return await this.installerFactory.install(updatedRequirement, recorder, options);
+    }
 }
 // Export a singleton instance
 export const requirementService = RequirementService.getInstance();

package/dist/services/ServerService.d.ts

@@ -14,12 +14,6 @@ export declare class ServerService {
      * Gets a server by name
      */
     getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;
-    /**
-     * Check for updates to requirements for a server category
-     * @param serverCategory The server category to check
-     * @private
-     */
-    private checkRequirementsForUpdate;
     /**
      * Gets the schema for a specific server in a category
      */