imcp 0.0.19 → 0.1.2

package/dist/services/MCPManager.js

@@ -3,19 +3,23 @@ import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js'
 import { ServerSchemaProvider } from '../core/loaders/ServerSchemaProvider.js';
 import { InstallationService } from './InstallationService.js';
 import { MCPEvent, } from '../core/metadatas/types.js';
-import { Logger } from '../utils/logger.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();
@@ -24,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);
@@ -53,6 +58,14 @@ export class MCPManager extends EventEmitter {
                 };
             }
             const installResult = await this.installationService.install(categoryName, serverName, requestOptions);
+            // Log the event with appropriate status
+            Logger.trackEvent(EventType.SERVER_INSTALL, {
+                status: installResult.success ? EventStatus.SUCCESS : EventStatus.FAILED,
+                errorMessage: !installResult.success ? installResult.message : undefined,
+                categoryName,
+                serverName,
+                ...requestOptions
+            });
             if (!installResult.success) {
                 return installResult;
             }
@@ -60,15 +73,24 @@ export class MCPManager extends EventEmitter {
             return installResult;
         }
         catch (error) {
-            console.error(`Unexpected error during installServer for ${serverName}:`, error);
+            const errorMessage = `Failed to install ${serverName}: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(errorMessage, error);
+            Logger.trackEvent(EventType.SERVER_INSTALL, {
+                status: EventStatus.FAILED,
+                errorMessage,
+                categoryName,
+                serverName,
+                ...requestOptions
+            });
             return {
                 success: false,
-                message: `Failed to install ${serverName}: ${error instanceof Error ? error.message : String(error)}`,
+                message: errorMessage,
                 error: error instanceof Error ? error : new Error(String(error)),
             };
         }
     }
     async uninstallServer(categoryName, serverName, options = {}) {
+        const { targets = [], removeData = false } = options;
         try {
             const serverCategory = await this.configProvider.getServerCategory(categoryName);
             if (!serverCategory) {
@@ -77,7 +99,6 @@ export class MCPManager extends EventEmitter {
                     message: `Server category ${categoryName} is not onboarded`,
                 };
             }
-            const { targets = [], removeData = false } = options;
             // Clear installation status for specified targets
             const currentStatus = serverCategory.installationStatus || {
                 requirementsStatus: {},
@@ -101,6 +122,13 @@ export class MCPManager extends EventEmitter {
             serversStatus[serverName] = serverStatus;
             // Update status keeping requirements
             await this.configProvider.updateInstallationStatus(categoryName, currentStatus.requirementsStatus || {}, serversStatus);
+            Logger.trackEvent(EventType.SERVER_UNINSTALL, {
+                status: EventStatus.SUCCESS,
+                categoryName,
+                serverName,
+                targets,
+                removeData
+            });
             this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName, targets });
             return {
                 success: true,
@@ -108,55 +136,22 @@ export class MCPManager extends EventEmitter {
             };
         }
         catch (error) {
+            const errorMessage = `Failed to uninstall ${serverName}: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.trackEvent(EventType.SERVER_UNINSTALL, {
+                status: EventStatus.FAILED,
+                errorMessage,
+                categoryName,
+                serverName,
+                targets: targets || [],
+                removeData: removeData || false
+            });
             return {
                 success: false,
-                message: `Failed to uninstall ${serverName}`,
+                message: errorMessage,
                 error: error,
             };
         }
     }
-    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);
-            return {
-                success: true,
-                message: `Successfully updated ${requirementName} to version ${updateVersion}`,
-            };
-        }
-        catch (error) {
-            console.error(`Error updating requirement ${requirementName}:`, error);
-            return {
-                success: false,
-                message: `Failed to update ${requirementName}: ${error instanceof Error ? error.message : String(error)}`,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-    }
     /**
      * Onboards a new feed configuration
      * @param config The feed configuration to onboard
@@ -164,6 +159,11 @@ export class MCPManager extends EventEmitter {
     async onboardFeed(config) {
         try {
             const result = await this.feedOnboardService.onboardFeed(config);
+            Logger.trackEvent(EventType.FEED_ONBOARD, {
+                status: result.status === OnboardingProcessStatus.SUCCEEDED ? EventStatus.SUCCESS : EventStatus.FAILED,
+                errorMessage: result.message,
+                feedConfig: config
+            });
             // After successful onboarding initiation, sync feeds to get the latest changes
             // Syncing should ideally happen after the PR is merged, but for now,
             // syncing here makes the new (pending) category available locally if needed.
@@ -172,7 +172,13 @@ export class MCPManager extends EventEmitter {
             return result;
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
             Logger.error('Failed to onboard feed in MCPManager:', error);
+            Logger.trackEvent(EventType.FEED_ONBOARD, {
+                status: EventStatus.FAILED,
+                errorMessage,
+                feedName: config.name
+            });
             throw error; // Rethrow or handle by returning a failed OperationStatus
         }
     }

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;