imcp 0.1.7 → 0.1.8-dev

package/src/services/RequirementService.ts

@@ -1,627 +0,0 @@
-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: InstallerFactory;
-
-    private constructor() {
-        this.installerFactory = createInstallerFactory(util.promisify(exec));
-    }
-
-    /**
-     * Get the singleton instance of RequirementService
-     * @returns The RequirementService instance
-     */
-    public static getInstance(): RequirementService {
-        if (!RequirementService.instance) {
-            RequirementService.instance = new 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> {
-        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
-     */
-    public async checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus, categoryName: string, serverName?: string): Promise<RequirementStatus> {
-        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 as any).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.
-     */
-    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;
-        }
-
-        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: 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);
-                                }
-
-                                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
- */
-    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
-export const requirementService = RequirementService.getInstance();