imcp 0.0.19 → 0.1.2

package/src/services/RequirementService.ts

@@ -1,16 +1,33 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../core/metadatas/types.js';
-import { createInstallerFactory } from '../core/installers/index.js';
+import {
+    RequirementConfig,
+    RequirementStatus,
+    ServerInstallOptions,
+    OperationStatus,
+    FeedConfiguration,
+    McpConfig,
+    ServerOperationResult,
+    MCPServerCategory
+} from '../core/metadatas/types.js';
+import { createInstallerFactory, InstallerFactory } 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 { UPDATE_CHECK_INTERVAL_MS } from '../core/metadatas/constants.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 {
     private static instance: RequirementService;
-    private installerFactory = createInstallerFactory(util.promisify(exec));
+    private installerFactory: InstallerFactory;
 
-    private constructor() { }
+    private constructor() {
+        this.installerFactory = createInstallerFactory(util.promisify(exec));
+    }
 
     /**
      * Get the singleton instance of RequirementService
@@ -23,107 +40,587 @@ export class RequirementService {
         return RequirementService.instance;
     }
 
+    private generateOperationId(): string {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * 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.
+     */
+    public async checkAndInstallRequirements(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult | null> {
+        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: McpConfig) => 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: RequirementConfig) => 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
+        });
+    }
+
+    /**
+     * 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.
+     */
+    private async installRequirementsInBackground(
+        categoryName: string,
+        serverName: string,
+        feedConfig: FeedConfiguration,
+        sortedRequirements: Array<{ name: string; version: string; order?: number }>,
+        options: ServerInstallOptions,
+        recoder: InstallOperationManager // Added recoder parameter
+    ): Promise<void> {
+        const configProvider = ConfigurationProvider.getInstance();
+        type RequirementType = { name: string; version: string; order?: number };
+        const requirementGroups = sortedRequirements.reduce<Record<number, RequirementType[]>>((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: RequirementConfig) => 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
+                });
+            }));
+        }
+    }
+
+    /**
+     * 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.
+     */
+    private async updateRequirementFailureStatus(
+        categoryName: string, requirementName: string, requirementType: string, errorMessage: string
+    ): Promise<void> {
+        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.
+     */
+    private async updateRequirementProgressStatus(
+        categoryName: string, requirementName: string, requirementType: string, operationId: string
+    ): Promise<void> {
+        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.
+     */
+    private async updateRequirementCompletionStatus(
+        categoryName: string, requirementName: string, installStatus: RequirementStatus, operationId: string
+    ): Promise<void> {
+        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.
+     */
+    private validateRequirement(requirement: RequirementConfig): void {
+        if (!requirement.name) { throw new Error('Requirement name is required'); }
+        if (!requirement.type) { throw new Error('Requirement type is required'); }
+        if (requirement.type === 'other' && !requirement.registry) {
+            throw new Error('Registry must be specified for requirement type "other"');
+        }
+        if (requirement.registry) {
+            const { githubRelease, artifacts } = requirement.registry;
+            if (githubRelease) {
+                if (!githubRelease.repository) { throw new Error('Repository is required for GitHub release registry'); }
+                if (!githubRelease.assetName) { throw new Error('Asset name is required for GitHub release registry'); }
+            }
+            if (artifacts) {
+                if (!artifacts.registryUrl) { throw new Error('Registry URL is required for artifacts registry'); }
+            }
+        }
+    }
+
+    /**
+     * Check for updates to requirements for all server categories
+     * This method is called periodically to check for updates
+     */
+    public async checkRequirementForUpdateAsync(): Promise<void> {
+        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)
+     */
+    public async checkServerRequirementForUpdateAsync(categoryName: string, serverName: string): Promise<void> {
+        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
+     */
+    private async checkRequirementsForUpdateInternal(serverCategory: MCPServerCategory, serverName?: string): Promise<void> {
+        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: string | undefined = 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: McpConfig) => 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: McpConfig) => 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
      */
     public async checkRequirementStatus(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
-        // Validate requirement
         this.validateRequirement(requirement);
-
-        // Check the installation status
         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
      */
-    public async checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus> {
-        // Validate requirement
+    public async checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus, categoryName: string, serverName?: string): Promise<RequirementStatus> {
         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;
         }
-
-        // Pass pythonEnv from currentStatus if it exists for pip packages
-        const options = requirement.type === 'pip' && currentStatus.pythonEnv
-            ? { settings: { pythonEnv: currentStatus.pythonEnv } }
+        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 as any).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
+     * 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.
      */
-    public async updateRequirement(requirement: RequirementConfig, updateVersion: string, options?: ServerInstallOptions): Promise<RequirementStatus> {
-        // Validate requirement
-        this.validateRequirement(requirement);
+    public async processRequirementUpdates(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<void> {
+        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;
+        }
 
-        // Create an updated requirement with the new version
-        const updatedRequirement: RequirementConfig = {
-            ...requirement,
-            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
-        };
+        const recoder = InstallOperationManager.getInstance(categoryName, serverName);
 
-        // Install the updated version
-        return await this.installerFactory.install(updatedRequirement, options);
-    }
+        try {
+            await recoder.recording(async () => {
+                const configProvider = ConfigurationProvider.getInstance();
+                const feedConfig = await configProvider.getFeedConfiguration(categoryName);
 
-    /**
-     * Validate a requirement configuration
-     * @param requirement The requirement to validate
-     * @throws Error if the requirement is invalid
-     */
-    private validateRequirement(requirement: RequirementConfig): void {
-        // Ensure requirement has required fields
-        if (!requirement.name) {
-            throw new Error('Requirement name is required');
-        }
+                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
+                }
 
-        if (!requirement.type) {
-            throw new Error('Requirement type is required');
-        }
+                const updatePromises = options.requirements?.map(async (reqToUpdate) => {
+                    const stepName = `${RecordingConstants.STEP_INSTALL_REQUIREMENT_PREFIX}: ${reqToUpdate.name}`;
+                    return recoder.recording(
+                        async () => {
+                            let reqConfig: RequirementConfig | undefined;
+                            let currentStatus: RequirementStatus | undefined | null;
+                            try {
+                                reqConfig = feedConfig.requirements?.find((r: RequirementConfig) => 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);
+                                }
 
-        // For type 'other', registry must be specified
-        if (requirement.type === 'other' && !requirement.registry) {
-            throw new Error('Registry must be specified for requirement type "other"');
-        }
+                                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);
+                                }
 
-        // Validate registry configuration if provided
-        if (requirement.registry) {
-            const { githubRelease, artifacts } = requirement.registry;
+                                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}`
+                                    }
+                                });
 
-            // Validate GitHub release configuration
-            if (githubRelease) {
-                if (!githubRelease.repository) {
-                    throw new Error('Repository is required for GitHub release registry');
-                }
+                                let currentOptions = { ...options };
+                                if (reqConfig.type === 'pip' && currentStatus.pythonEnv && !currentOptions?.settings?.pythonEnv) {
+                                    currentOptions = {
+                                        ...currentOptions,
+                                        settings: { ...currentOptions?.settings, pythonEnv: currentStatus.pythonEnv }
+                                    };
+                                }
 
-                if (!githubRelease.assetName) {
-                    throw new Error('Asset name is required for GitHub release registry');
-                }
-            }
+                                const updatedStatus = await this.updateRequirement(reqConfig, reqToUpdate.version, recoder, currentOptions);
 
-            // Validate artifacts registry configuration
-            if (artifacts) {
-                if (!artifacts.registryUrl) {
-                    throw new Error('Registry URL is required for artifacts registry');
+                                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
+ */
+    private async updateRequirement(requirement: RequirementConfig, updateVersion: string, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        this.validateRequirement(requirement);
+        const updatedRequirement: RequirementConfig = {
+            ...requirement,
+            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
+        };
+        return await this.installerFactory.install(updatedRequirement, recorder, options);
+    }
 }
 
 // Export a singleton instance