imcp 0.0.19 → 0.1.2

package/src/services/MCPManager.ts

@@ -13,17 +13,19 @@ import {
   InstallationStatus,
   FeedConfiguration,
 } from '../core/metadatas/types.js';
-import { OperationStatus } from '../core/onboard/OnboardStatus.js';
-import { Logger } from '../utils/logger.js';
+import { OnboardingProcessStatus, OperationStatus } from '../core/onboard/OnboardStatus.js';
+import { Logger, EventType, EventStatus } from '../utils/logger.js';
 import { FeedOnboardService } from '../core/onboard/FeedOnboardService.js';
 import path from 'path';
 import { Server } from 'http';
+import { RequirementService } from './RequirementService.js';
 
 export class MCPManager extends EventEmitter {
   private installationService: InstallationService;
   private configProvider: ConfigurationProvider;
   private feedOnboardService: FeedOnboardService;
   private schemaProvider: ServerSchemaProvider;
+  private requirementsService: RequirementService;
 
   constructor() {
     super();
@@ -31,6 +33,7 @@ export class MCPManager extends EventEmitter {
     this.schemaProvider = ServerSchemaProvider.getInstance();
     this.installationService = new InstallationService();
     this.feedOnboardService = new FeedOnboardService();
+    this.requirementsService = RequirementService.getInstance();
   }
 
   async syncFeeds(): Promise<void> {
@@ -41,6 +44,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);
       throw error;
@@ -78,6 +82,15 @@ 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;
       }
@@ -86,10 +99,19 @@ 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)),
       };
     }
@@ -100,6 +122,8 @@ export class MCPManager extends EventEmitter {
     serverName: string,
     options: ServerUninstallOptions = {}
   ): Promise<ServerOperationResult> {
+    const { targets = [], removeData = false } = options;
+
     try {
       const serverCategory = await this.configProvider.getServerCategory(categoryName);
       if (!serverCategory) {
@@ -109,8 +133,6 @@ export class MCPManager extends EventEmitter {
         };
       }
 
-      const { targets = [], removeData = false } = options;
-
       // Clear installation status for specified targets
       const currentStatus: InstallationStatus = serverCategory.installationStatus || {
         requirementsStatus: {},
@@ -141,6 +163,13 @@ export class MCPManager extends EventEmitter {
         currentStatus.requirementsStatus || {},
         serversStatus
       );
+      Logger.trackEvent(EventType.SERVER_UNINSTALL, {
+        status: EventStatus.SUCCESS,
+        categoryName,
+        serverName,
+        targets,
+        removeData
+      });
 
       this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName, targets });
 
@@ -149,68 +178,21 @@ export class MCPManager extends EventEmitter {
         message: `Successfully uninstalled ${serverName} from ${targets.join(', ')}`,
       };
     } catch (error) {
-      return {
-        success: false,
-        message: `Failed to uninstall ${serverName}`,
-        error: error as Error,
-      };
-    }
-  }
-
-  async updateRequirement(
-    categoryName: string,
-    serverName: string,
-    requirementName: string,
-    updateVersion: string
-  ): Promise<ServerOperationResult> {
-    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(
+      const errorMessage = `Failed to uninstall ${serverName}: ${error instanceof Error ? error.message : String(error)}`;
+      
+      Logger.trackEvent(EventType.SERVER_UNINSTALL, {
+        status: EventStatus.FAILED,
+        errorMessage,
         categoryName,
-        requirementName,
-        updatedStatus
-      );
+        serverName,
+        targets: targets || [],
+        removeData: removeData || false
+      });
 
-      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)),
+        message: errorMessage,
+        error: error as Error,
       };
     }
   }
@@ -222,6 +204,13 @@ export class MCPManager extends EventEmitter {
   async onboardFeed(config: FeedConfiguration): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
     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.
@@ -229,7 +218,15 @@ export class MCPManager extends EventEmitter {
       await this.syncFeeds();
       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
     }
   }