imcp 0.1.1 → 0.1.3

package/dist/services/InstallationService.js

@@ -1,350 +1,82 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { exec } from 'child_process';
-import util from 'util';
-import { createInstallerFactory } from '../core/installers/index.js';
-import { SUPPORTED_CLIENTS } from '../core/metadatas/constants.js';
 import { ClientInstaller } from '../core/installers/clients/ClientInstaller.js';
 import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js';
 import { Logger } from '../utils/logger.js';
-const execPromise = util.promisify(exec);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import { requirementService } from './RequirementService.js';
+import { InstallOperationManager } from '../core/loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../core/metadatas/recordingConstants.js';
 /**
  * Handles the actual installation process for an MCP server.
  */
 export class InstallationService {
-    activeInstallations = new Map();
-    installerFactory;
     constructor() {
-        this.installerFactory = createInstallerFactory();
-    }
-    generateOperationId() {
-        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        // Constructor is now empty after removing installerFactory initialization
     }
     /**
-     * Installs a server based on the provided options and feed configuration.
+     * Installs a server based on the provided options.
+     * @param categoryName The category name of the server.
      * @param serverName The name of the server to install.
      * @param options The installation options.
      * @returns A result object indicating success or failure.
      */
     async install(categoryName, serverName, options) {
+        // Reset any previous operation status for this server before starting a new one.
+        const recoder = await InstallOperationManager.getInstance(categoryName, serverName).resetOperation();
         const configProvider = ConfigurationProvider.getInstance();
-        const clients = options.targetClients || Object.keys(SUPPORTED_CLIENTS);
+        const clients = options.targetClients || [];
         // Process updates for requirements if specified in options
-        // Fire off requirement updates in the background without awaiting completion
         if (options.requirements && options.requirements.length > 0) {
-            // Start the process but don't await it - it will run in the background
-            this.processRequirementUpdates(categoryName, serverName, options)
-                .catch(error => {
-                console.error(`Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`);
+            recoder.recordingAsync(() => requirementService.processRequirementUpdates(categoryName, serverName, options), {
+                stepName: RecordingConstants.STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE,
+                onError: (error) => {
+                    const errorMsg = `Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`;
+                    Logger.error(errorMsg);
+                    return errorMsg;
+                },
+                onComplete: () => {
+                    if (clients.length === 0)
+                        recoder.markOverallStatus('completed', 'Requirement updates completed.');
+                }
             });
         }
-        // Check if server is already ready
-        const isReady = await configProvider.isServerReady(categoryName, serverName, clients);
+        if (!clients || clients.length === 0) {
+            const message = 'No clients specified for installation.';
+            return { success: true, message };
+        }
+        // Check if the server is already installed and ready
+        const readyMessage = 'Server and clients are already installed and ready';
+        const isReady = await recoder.recording(() => configProvider.isServerReady(categoryName, serverName, clients), {
+            stepName: RecordingConstants.STEP_CHECK_SERVER_READINESS,
+            inProgressMessage: 'Checking if server is already ready.',
+            endMessage: (ready) => ready ? 'Server and clients are already installed and ready' : 'Server is not ready. Proceeding with installation.',
+        });
         if (isReady) {
             return {
-                success: true,
-                message: 'Server and clients are already installed and ready',
+                success: true, message: readyMessage,
                 status: [{
                         status: 'completed',
                         type: 'install',
                         target: 'server',
-                        message: 'Server and clients are already installed and ready'
+                        message: readyMessage,
                     }]
             };
         }
         // Create new ClientInstaller instance for handling installation
         const clientInstaller = new ClientInstaller(categoryName, serverName, clients);
-        const requirementsResult = await this.checkAndInstallRequirements(categoryName, serverName, options);
-        if (requirementsResult) {
+        // Check and install requirements using RequirementService
+        const requirementsResult = await requirementService.checkAndInstallRequirements(categoryName, serverName, options);
+        // trigger a backend requirement check
+        await requirementService.checkServerRequirementForUpdateAsync(categoryName, serverName)
+            .then(() => {
+            Logger.info(`Requirement check for ${categoryName}:${serverName} completed successfully.`);
+        })
+            .catch((error) => {
+            Logger.error(`Requirement check for ${categoryName}:${serverName} failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        if (requirementsResult && !requirementsResult.success) {
+            await recoder.recordStep('RequirementInstallationCheck', 'failed', requirementsResult.error?.message || requirementsResult.message || 'Requirement installation failed.');
             return requirementsResult;
         }
-        // Process client installation regardless of requirements state
-        // Each client installer will check requirements before actual installation
         return await clientInstaller.install(options);
     }
-    /**
-     * 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 requirements The requirements to update
-     */
-    async processRequirementUpdates(categoryName, serverName, options) {
-        // Use UpdateCheckTracker to prevent concurrent updates
-        const updateCheckTracker = await import('../utils/UpdateCheckTracker.js').then(m => m.updateCheckTracker);
-        const operationKey = `requirement-updates-${categoryName}-${serverName}`;
-        // Check if there's already an update operation in progress for this server
-        const canProceed = await updateCheckTracker.startOperation(operationKey);
-        if (!canProceed) {
-            console.log(`Requirement updates for ${categoryName}/${serverName} already in progress, skipping`);
-            return;
-        }
-        try {
-            const configProvider = ConfigurationProvider.getInstance();
-            const feedConfig = await configProvider.getFeedConfiguration(categoryName);
-            if (!feedConfig) {
-                console.error(`Feed configuration not found for category: ${categoryName}`);
-                return;
-            }
-            // Import the RequirementService
-            const { requirementService } = await import('./RequirementService.js');
-            // Create an array of promises to update all requirements in parallel
-            const updatePromises = options.requirements?.map(async (reqToUpdate) => {
-                try {
-                    // Find the full requirement config
-                    const reqConfig = feedConfig.requirements?.find((r) => r.name === reqToUpdate.name);
-                    if (!reqConfig) {
-                        console.error(`Requirement configuration not found for: ${reqToUpdate.name}`);
-                        return;
-                    }
-                    // Get current status
-                    const currentStatus = await configProvider.getRequirementStatus(categoryName, reqToUpdate.name);
-                    if (!currentStatus) {
-                        console.error(`No current status found for requirement: ${reqToUpdate.name}`);
-                        return;
-                    }
-                    // Update requirement status to indicate update in progress
-                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-                        ...currentStatus,
-                        name: reqToUpdate.name,
-                        type: currentStatus.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}`
-                        }
-                    });
-                    // For pip requirements, check if we have a stored pythonEnv
-                    if (reqConfig.type === 'pip' && currentStatus.pythonEnv && !options?.settings?.pythonEnv) {
-                        options = {
-                            ...options,
-                            settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
-                        };
-                    }
-                    // Update the requirement with options for pip environment
-                    const updatedStatus = await requirementService.updateRequirement(reqConfig, reqToUpdate.version, options);
-                    // Update requirement status
-                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-                        ...updatedStatus,
-                        name: reqToUpdate.name,
-                        type: updatedStatus.type || currentStatus.type || 'unknown',
-                        installed: updatedStatus.installed,
-                        inProgress: false,
-                        operationStatus: {
-                            status: updatedStatus.installed ? 'completed' : 'failed',
-                            type: 'update',
-                            target: 'requirement',
-                            message: updatedStatus.installed
-                                ? `Successfully updated ${reqToUpdate.name} to version ${reqToUpdate.version}`
-                                : `Failed to update ${reqToUpdate.name} to version ${reqToUpdate.version}`
-                        },
-                        availableUpdate: updatedStatus.installed ? undefined : currentStatus.availableUpdate
-                    });
-                    console.log(`Requirement ${reqToUpdate.name} updated to version ${reqToUpdate.version}`);
-                }
-                catch (error) {
-                    console.error(`Error updating requirement ${reqToUpdate.name}:`, error);
-                    // Update status to indicate failure
-                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-                        name: reqToUpdate.name,
-                        type: 'unknown',
-                        installed: false,
-                        inProgress: false,
-                        error: error instanceof Error ? error.message : String(error),
-                        operationStatus: {
-                            status: 'failed',
-                            type: 'update',
-                            target: 'requirement',
-                            message: `Error updating requirement: ${error instanceof Error ? error.message : String(error)}`
-                        }
-                    });
-                }
-            });
-            // Wait for all updates to complete in parallel if there are any
-            if (updatePromises) {
-                await Promise.all(updatePromises);
-            }
-        }
-        finally {
-            // Always release the lock when done, even if there was an error
-            await updateCheckTracker.endOperation(operationKey);
-        }
-    }
-    /**
-     * 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
-     */
-    async checkAndInstallRequirements(categoryName, serverName, options) {
-        const configProvider = ConfigurationProvider.getInstance();
-        // Get feed configuration to get requirements
-        const feedConfig = await configProvider.getFeedConfiguration(categoryName);
-        if (!feedConfig) {
-            return {
-                success: false,
-                message: 'Feed configuration not found',
-                status: [{
-                        status: 'failed',
-                        type: 'install',
-                        target: 'server',
-                        message: 'Feed configuration not found'
-                    }]
-            };
-        }
-        // Find server config and verify requirements
-        const serverConfig = feedConfig.mcpServers.find((s) => s.name === serverName);
-        if (!serverConfig?.dependencies?.requirements) {
-            Logger.debug(`No requirements for ${serverName}`);
-            return null;
-        }
-        // Check all requirements installation status
-        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'
-            };
-            return await this.installerFactory.checkInstallation(reqConfig, options);
-        }));
-        // If all requirements are installed and ready, no need to proceed with installation
-        if (requirementStatuses.every(status => status.installed)) {
-            // Check if requirements are ready via ConfigurationProvider
-            const requirementsReady = await configProvider.isRequirementsReady(categoryName, serverName);
-            // Update requirement status if not ready
-            if (!requirementsReady) {
-                for (const status of requirementStatuses) {
-                    await configProvider.updateRequirementStatus(categoryName, status.name, status);
-                }
-            }
-            return null;
-        }
-        // Sort requirements by order for installation
-        const sortedRequirements = [...serverConfig.dependencies.requirements].sort((a, b) => {
-            const orderA = a.order ?? Infinity;
-            const orderB = b.order ?? Infinity;
-            return orderA - orderB;
-        });
-        // Start requirements installation in background
-        this.installRequirementsInBackground(categoryName, sortedRequirements, options)
-            .catch(error => {
-            Logger.error(`Error in background requirement installations: ${error instanceof Error ? error.message : String(error)}`);
-        });
-        // Return immediately while installation continues in background
-        return null;
-    }
-    /**
-     * Installs requirements in background without blocking the main thread
-     * Requirements with the same order are installed in parallel
-     */
-    async installRequirementsInBackground(categoryName, sortedRequirements, options) {
-        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;
-        }, {});
-        // Process each group in sequence, but requirements within group in parallel
-        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) => {
-                try {
-                    const feeds = await configProvider.getFeedConfiguration(categoryName);
-                    const requirementConfig = feeds?.requirements?.find((r) => r.name === requirement.name) || {
-                        name: requirement.name,
-                        version: requirement.version,
-                        type: 'npm'
-                    };
-                    // For pip requirements, check if we need to use stored pythonEnv
-                    const currentStatus = await configProvider.getRequirementStatus(categoryName, requirement.name);
-                    if (requirementConfig.type === 'pip' && currentStatus?.pythonEnv && !options?.settings?.pythonEnv) {
-                        options = {
-                            ...options,
-                            settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
-                        };
-                    }
-                    const installer = this.installerFactory.getInstaller(requirementConfig);
-                    if (!installer) {
-                        await this.updateRequirementFailureStatus(categoryName, requirement.name, requirementConfig.type, `No installer found for requirement type: ${requirementConfig.type}`);
-                        return;
-                    }
-                    const operationId = this.generateOperationId();
-                    await this.updateRequirementProgressStatus(categoryName, requirement.name, requirementConfig.type, operationId);
-                    const installStatus = await installer.install(requirementConfig, options);
-                    await this.updateRequirementCompletionStatus(categoryName, requirement.name, installStatus, operationId);
-                }
-                catch (error) {
-                    await this.updateRequirementFailureStatus(categoryName, requirement.name, 'unknown', error instanceof Error ? error.message : String(error));
-                }
-            }));
-        }
-    }
-    /**
-     * Helper to update requirement status for failure case
-     */
-    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
-     */
-    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
-     */
-    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
-            }
-        });
-    }
 }
-// Export a singleton instance (optional)
-// export const installationService = new InstallationService();
 //# sourceMappingURL=InstallationService.js.map

package/dist/services/MCPManager.d.ts

@@ -6,6 +6,7 @@ export declare class MCPManager extends EventEmitter {
     private configProvider;
     private feedOnboardService;
     private schemaProvider;
+    private requirementsService;
     constructor();
     syncFeeds(): Promise<void>;
     initialize(feedFile?: string, schemasDirectory?: string): Promise<void>;
@@ -14,7 +15,6 @@ export declare class MCPManager extends EventEmitter {
     getServerMcpConfig(categoryName: string, serverName: string): Promise<import("../core/metadatas/types.js").McpConfig | undefined>;
     installServer(categoryName: string, serverName: string, requestOptions?: ServerInstallOptions): Promise<ServerOperationResult>;
     uninstallServer(categoryName: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
-    updateRequirement(categoryName: string, serverName: string, requirementName: string, updateVersion: string): Promise<ServerOperationResult>;
     /**
      * Onboards a new feed configuration
      * @param config The feed configuration to onboard

package/dist/services/MCPManager.js

@@ -6,17 +6,20 @@ import { MCPEvent, } from '../core/metadatas/types.js';
 import { OnboardingProcessStatus } from '../core/onboard/OnboardStatus.js';
 import { Logger, EventType, EventStatus } from '../utils/logger.js';
 import { FeedOnboardService } from '../core/onboard/FeedOnboardService.js';
+import { RequirementService } from './RequirementService.js';
 export class MCPManager extends EventEmitter {
     installationService;
     configProvider;
     feedOnboardService;
     schemaProvider;
+    requirementsService;
     constructor() {
         super();
         this.configProvider = ConfigurationProvider.getInstance();
         this.schemaProvider = ServerSchemaProvider.getInstance();
         this.installationService = new InstallationService();
         this.feedOnboardService = new FeedOnboardService();
+        this.requirementsService = RequirementService.getInstance();
     }
     async syncFeeds() {
         await this.configProvider.syncFeeds();
@@ -25,6 +28,7 @@ export class MCPManager extends EventEmitter {
         try {
             await this.configProvider.initialize(feedFile);
             await this.schemaProvider.initialize(schemasDirectory);
+            await this.requirementsService.checkRequirementForUpdateAsync();
         }
         catch (error) {
             console.error("Error during MCPManager initialization:", error);
@@ -148,64 +152,6 @@ export class MCPManager extends EventEmitter {
             };
         }
     }
-    async updateRequirement(categoryName, serverName, requirementName, updateVersion) {
-        try {
-            const { requirementService } = await import('./RequirementService.js');
-            const serverCategory = await this.configProvider.getServerCategory(categoryName);
-            if (!serverCategory) {
-                return {
-                    success: false,
-                    message: `Server category ${categoryName} is not onboarded`,
-                };
-            }
-            if (!serverCategory.feedConfiguration) {
-                return {
-                    success: false,
-                    message: `Server category ${categoryName} has no feed configuration`,
-                };
-            }
-            // Find the requirement
-            const requirement = serverCategory.feedConfiguration.requirements.find(r => r.name === requirementName);
-            if (!requirement) {
-                return {
-                    success: false,
-                    message: `Requirement ${requirementName} not found in category ${categoryName}`,
-                };
-            }
-            // Update the requirement using requirementService
-            const updatedStatus = await requirementService.updateRequirement(requirement, updateVersion);
-            // Update the status in configuration
-            await this.configProvider.updateRequirementStatus(categoryName, requirementName, updatedStatus);
-            Logger.trackEvent(EventType.REQUIREMENT_UPDATE, {
-                status: EventStatus.SUCCESS,
-                categoryName,
-                serverName,
-                requirementName,
-                updateVersion
-            });
-            return {
-                success: true,
-                message: `Successfully updated ${requirementName} to version ${updateVersion}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = `Failed to update ${requirementName}: ${error instanceof Error ? error.message : String(error)}`;
-            console.error(`Error updating requirement ${requirementName}:`, error);
-            Logger.trackEvent(EventType.REQUIREMENT_UPDATE, {
-                status: EventStatus.FAILED,
-                errorMessage,
-                categoryName,
-                serverName,
-                requirementName,
-                updateVersion
-            });
-            return {
-                success: false,
-                message: errorMessage,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-    }
     /**
      * Onboards a new feed configuration
      * @param config The feed configuration to onboard

package/dist/services/RequirementService.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../core/metadatas/types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions, ServerOperationResult } from '../core/metadatas/types.js';
 /**
  * Service responsible for managing requirements installation and status
  */
@@ -11,30 +11,103 @@ export declare class RequirementService {
      * @returns The RequirementService instance
      */
     static getInstance(): RequirementService;
+    private generateOperationId;
+    /**
+     * 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.
+     */
+    checkAndInstallRequirements(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult | null>;
+    /**
+     * 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 installRequirementsInBackground;
+    /**
+     * 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 updateRequirementFailureStatus;
+    /**
+     * 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 updateRequirementProgressStatus;
+    /**
+     * 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 updateRequirementCompletionStatus;
+    /**
+     * Validate a requirement configuration.
+     * @param requirement The requirement to validate.
+     * @throws Error if the requirement is invalid.
+     */
+    private validateRequirement;
+    /**
+     * Check for updates to requirements for all server categories
+     * This method is called periodically to check for updates
+     */
+    checkRequirementForUpdateAsync(): Promise<void>;
+    /**
+     * 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)
+     */
+    checkServerRequirementForUpdateAsync(categoryName: string, serverName: string): Promise<void>;
+    /**
+     * 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 checkRequirementsForUpdateInternal;
     /**
      * Check the installation status of a requirement
      * @param requirement The requirement to check
+     * @param options Optional installation options
      * @returns The installation status
      */
     checkRequirementStatus(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * 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
      */
-    checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
+    checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus, categoryName: string, serverName?: string): Promise<RequirementStatus>;
     /**
-     * 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.
      */
-    updateRequirement(requirement: RequirementConfig, updateVersion: string, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    processRequirementUpdates(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<void>;
     /**
-     * Validate a requirement configuration
-     * @param requirement The requirement to validate
-     * @throws Error if the requirement is invalid
-     */
-    private validateRequirement;
+ * 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 updateRequirement;
 }
 export declare const requirementService: RequirementService;