imcp 0.0.19 → 0.1.2

package/dist/core/onboard/InstallOperationManager.js

@@ -0,0 +1,144 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SETTINGS_DIR } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+const INSTALL_STATUS_DIR = path.join(SETTINGS_DIR, 'install');
+const INSTALL_OPERATION_STATUS_FILE = path.join(INSTALL_STATUS_DIR, 'InstallOperationStatus.json');
+export class InstallOperationManager {
+    static instance;
+    installOperationStatus = {};
+    statusLock = Promise.resolve();
+    constructor() {
+        this.loadStatuses().catch(error => Logger.error('Failed to initialize InstallOperationManager:', error));
+    }
+    static getInstance() {
+        if (!InstallOperationManager.instance) {
+            InstallOperationManager.instance = new InstallOperationManager();
+        }
+        return InstallOperationManager.instance;
+    }
+    async withLock(operation) {
+        const current = this.statusLock;
+        let resolve;
+        this.statusLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async loadStatuses() {
+        await this.withLock(async () => {
+            try {
+                await fs.mkdir(INSTALL_STATUS_DIR, { recursive: true });
+                const data = await fs.readFile(INSTALL_OPERATION_STATUS_FILE, 'utf-8');
+                this.installOperationStatus = JSON.parse(data);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    this.installOperationStatus = {};
+                    await this.saveStatuses(); // Create the file if it doesn't exist
+                }
+                else {
+                    Logger.error('Failed to load install operation statuses:', error);
+                    this.installOperationStatus = {}; // Initialize with empty statuses in case of other errors
+                }
+            }
+        });
+    }
+    async saveStatuses() {
+        await fs.mkdir(INSTALL_STATUS_DIR, { recursive: true });
+        await fs.writeFile(INSTALL_OPERATION_STATUS_FILE, JSON.stringify(this.installOperationStatus, null, 2));
+    }
+    createOperationKey(categoryName, serverName) {
+        return `${categoryName}-${serverName}`;
+    }
+    async recordStep(categoryName, serverName, stepName, isSucceeded, message) {
+        return await this.withLock(async () => {
+            const operationKey = this.createOperationKey(categoryName, serverName);
+            let operationDetails = this.installOperationStatus[operationKey];
+            const newStep = {
+                name: stepName,
+                isSucceeded,
+                message,
+                timestamp: new Date().toISOString(),
+            };
+            if (!operationDetails) {
+                operationDetails = {
+                    currentStep: stepName,
+                    steps: [newStep],
+                    lastUpdated: new Date().toISOString(),
+                    error: !isSucceeded ? message : undefined,
+                    overallStatus: isSucceeded ? 'in-progress' : 'failed',
+                };
+            }
+            else {
+                operationDetails.steps.push(newStep);
+                operationDetails.currentStep = stepName;
+                operationDetails.lastUpdated = new Date().toISOString();
+                if (!isSucceeded) {
+                    operationDetails.overallStatus = 'failed';
+                    if (!operationDetails.error) { // Store the first error
+                        operationDetails.error = message;
+                    }
+                }
+                else {
+                    // If this step succeeded, check if all previous steps also succeeded.
+                    // If a previous step failed, the overall status remains 'failed'.
+                    // If all steps are successful so far, it's 'in-progress' unless it's a known completion step.
+                    if (operationDetails.overallStatus !== 'failed') {
+                        if (stepName.toLowerCase().includes('completed') || stepName.toLowerCase().includes('succeeded')) {
+                            // Check if this is a "final" success step
+                            const isFinalSuccess = operationDetails.steps.every(s => s.isSucceeded);
+                            operationDetails.overallStatus = isFinalSuccess ? 'completed' : 'in-progress';
+                            if (isFinalSuccess)
+                                operationDetails.error = undefined; // Clear error on final success
+                        }
+                        else {
+                            operationDetails.overallStatus = 'in-progress';
+                        }
+                    }
+                }
+            }
+            // Special handling for the "InstallCompleted" step or similar final step names
+            if (stepName === 'InstallCompleted') {
+                operationDetails.overallStatus = isSucceeded ? 'completed' : 'failed';
+                if (isSucceeded)
+                    operationDetails.error = undefined;
+            }
+            this.installOperationStatus[operationKey] = operationDetails;
+            await this.saveStatuses();
+            return operationDetails;
+        });
+    }
+    /**
+     * Resets (deletes) the operation status for a given category and server.
+     * This is useful to call before starting a new installation attempt.
+     * @param categoryName The name of the category.
+     * @param serverName The name of the server.
+     */
+    async resetOperation(categoryName, serverName) {
+        await this.withLock(async () => {
+            const operationKey = this.createOperationKey(categoryName, serverName);
+            if (this.installOperationStatus[operationKey]) {
+                delete this.installOperationStatus[operationKey];
+                Logger.info(`Reset installation operation status for ${operationKey}`);
+                await this.saveStatuses();
+            }
+        });
+    }
+    async getDetails(categoryName, serverName) {
+        await this.loadStatuses(); // Ensure latest statuses are loaded
+        const operationKey = this.createOperationKey(categoryName, serverName);
+        return this.installOperationStatus[operationKey];
+    }
+    async getAllDetails() {
+        await this.loadStatuses();
+        return this.installOperationStatus;
+    }
+}
+// Export singleton instance
+export const installOperationManager = InstallOperationManager.getInstance();
+//# sourceMappingURL=InstallOperationManager.js.map

package/dist/core/onboard/OnboardStatusManager.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { SETTINGS_DIR } from '../metadatas/constants.js';
 import { OnboardingProcessStatus } from './OnboardStatus.js';
 import { Logger } from '../../utils/logger.js';
+import * as RecordingConstants from '../metadatas/recordingConstants.js';
 const ONBOARD_STATUS_DIR = path.join(SETTINGS_DIR, 'onboard');
 const CATEGORY_OPERATIONS_STATUS_FILE = path.join(ONBOARD_STATUS_DIR, 'OnboardStatus.json');
 const FEED_CONFIG_DIR = path.join(ONBOARD_STATUS_DIR, 'feed_configs'); // Staging for feed configs during operation
@@ -267,7 +268,7 @@ export class OnboardStatusManager {
             feedName: categoryName,
             serverName,
             status: OnboardingProcessStatus.PENDING,
-            steps: [{ stepName: 'Initiated', timestamp: new Date().toISOString() }],
+            steps: [{ stepName: RecordingConstants.STEP_INITIATED, timestamp: new Date().toISOString() }],
             lastUpdated: new Date().toISOString(),
             operationType,
             errorMessage: undefined,

package/dist/core/validators/StdioServerValidator.js

@@ -6,6 +6,7 @@ import { MACRO_EXPRESSIONS, resolveNpmModulePath } from "../../utils/macroExpres
 import { getSystemPythonPackageDirectory } from "../../utils/osUtils.js";
 import { SETTINGS_DIR } from "../metadatas/constants.js";
 import path from "path";
+import { InstallOperationManager } from "../loaders/InstallOperationManager.js";
 const execPromise = util.promisify(exec);
 /**
  * Validates MCP server configurations for stdio mode
@@ -45,7 +46,7 @@ export class StdioServerValidator {
      * @param requirement The requirement config to validate and install
      * @returns true if requirement is successfully installed/validated
      */
-    async validateRequirement(requirement) {
+    async validateRequirement(requirement, recorder) {
         try {
             Logger.debug(`Validating/installing requirement: ${requirement.name}`);
             const installer = this.installerFactory.getInstaller(requirement);
@@ -55,7 +56,7 @@ export class StdioServerValidator {
                 throw new Error(msg);
             }
             const targetDir = this._getRequirementFolderPath(requirement);
-            const status = await installer.install(requirement, { settings: { folderName: targetDir } });
+            const status = await installer.install(requirement, recorder, { settings: { folderName: targetDir } });
             if (!status.installed) {
                 const msg = `Failed to install requirement ${requirement.name}: ${status.error || 'Unknown error'}`;
                 Logger.error(msg);
@@ -257,7 +258,7 @@ export class StdioServerValidator {
                         version: req.version,
                         type: 'npm' // Default to npm if not specified
                     };
-                    const isValid = await this.validateRequirement(reqConfig);
+                    const isValid = await this.validateRequirement(reqConfig, InstallOperationManager.getInstance(config.name, server.name));
                     if (!isValid) {
                         throw new Error(`Dependency validation failed for: ${req.name}`);
                     }

package/dist/services/InstallationService.d.ts

@@ -3,48 +3,13 @@ import { ServerInstallOptions, ServerOperationResult } from '../core/metadatas/t
  * Handles the actual installation process for an MCP server.
  */
 export declare class InstallationService {
-    private activeInstallations;
-    private installerFactory;
     constructor();
-    private generateOperationId;
     /**
-     * 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.
      */
     install(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult>;
-    /**
-     * 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
-     */
-    private processRequirementUpdates;
-    /**
-     * 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
-     */
-    private checkAndInstallRequirements;
-    /**
-     * Installs requirements in background without blocking the main thread
-     * Requirements with the same order are installed in parallel
-     */
-    private installRequirementsInBackground;
-    /**
-     * Helper to update requirement status for failure case
-     */
-    private updateRequirementFailureStatus;
-    /**
-     * Helper to update requirement status for in-progress case
-     */
-    private updateRequirementProgressStatus;
-    /**
-     * Helper to update requirement status for completion case
-     */
-    private updateRequirementCompletionStatus;
 }

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