imcp 0.1.4 → 0.1.5

package/src/services/MCPManager.ts

@@ -1,249 +0,0 @@
-import { EventEmitter } from 'events';
-import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js';
-import { ServerSchemaProvider } from '../core/loaders/ServerSchemaProvider.js';
-import { InstallationService } from './InstallationService.js';
-import {
-  MCPEvent,
-  MCPEventData,
-  MCPServerCategory,
-  ServerInstallOptions,
-  ServerCategoryListOptions,
-  ServerOperationResult,
-  ServerUninstallOptions,
-  InstallationStatus,
-  FeedConfiguration,
-} from '../core/metadatas/types.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();
-    this.configProvider = ConfigurationProvider.getInstance();
-    this.schemaProvider = ServerSchemaProvider.getInstance();
-    this.installationService = new InstallationService();
-    this.feedOnboardService = new FeedOnboardService();
-    this.requirementsService = RequirementService.getInstance();
-  }
-
-  async syncFeeds(): Promise<void> {
-    await this.configProvider.syncFeeds();
-  }
-
-  async initialize(feedFile?: string, schemasDirectory?: string): Promise<void> {
-    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;
-    }
-  }
-
-  async listServerCategories(options: ServerCategoryListOptions = {}): Promise<MCPServerCategory[]> {
-    const { local = true } = options;
-    if (local) {
-      return await this.configProvider.getServerCategories();
-    }
-    return [];
-  }
-
-  async getFeedConfiguration(categoryName: string) {
-    return this.configProvider.getFeedConfiguration(categoryName);
-  }
-
-  async getServerMcpConfig(categoryName: string, serverName: string) {
-    return this.configProvider.getServerMcpConfig(categoryName, serverName);
-  }
-
-  async installServer(
-    categoryName: string,
-    serverName: string,
-    requestOptions: ServerInstallOptions = {}
-  ): Promise<ServerOperationResult> {
-    try {
-      const server = await this.configProvider.getServerCategory(categoryName);
-      if (!server) {
-        return {
-          success: false,
-          message: `Server category ${categoryName} is not onboarded`,
-        };
-      }
-      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;
-      }
-
-      this.emit(MCPEvent.SERVER_INSTALLED, { server });
-      return installResult;
-
-    } catch (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: errorMessage,
-        error: error instanceof Error ? error : new Error(String(error)),
-      };
-    }
-  }
-
-  async uninstallServer(
-    categoryName: string,
-    serverName: string,
-    options: ServerUninstallOptions = {}
-  ): Promise<ServerOperationResult> {
-    const { targets = [], removeData = false } = options;
-
-    try {
-      const serverCategory = await this.configProvider.getServerCategory(categoryName);
-      if (!serverCategory) {
-        return {
-          success: false,
-          message: `Server category ${categoryName} is not onboarded`,
-        };
-      }
-
-      // Clear installation status for specified targets
-      const currentStatus: InstallationStatus = serverCategory.installationStatus || {
-        requirementsStatus: {},
-        serversStatus: {},
-        lastUpdated: new Date().toISOString()
-      };
-      const serversStatus = currentStatus.serversStatus || {};
-      const serverStatus = serversStatus[serverName] || { installedStatus: {}, name: serverName };
-
-      // Only reset installedStatus for specified targets
-      for (const target of targets) {
-        if (serverStatus.installedStatus) {
-          delete serverStatus.installedStatus[target];
-        }
-      }
-      if (removeData) {
-        for (const target of targets) {
-          await this.configProvider.removeServerFromClientMCPSettings(serverName, target);
-        }
-      }
-
-      // Update server status
-      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,
-        message: `Successfully uninstalled ${serverName} from ${targets.join(', ')}`,
-      };
-    } 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: errorMessage,
-        error: error as Error,
-      };
-    }
-  }
-
-  /**
-   * Onboards a new feed configuration
-   * @param config The feed configuration to onboard
-   */
-  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.
-      // Consider if syncFeeds should be conditional based on operation status or handled differently.
-      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
-    }
-  }
-
-  // Type-safe event emitter methods
-  emit<E extends MCPEvent>(event: E, data: MCPEventData[E]): boolean {
-    return super.emit(event, data);
-  }
-
-  on<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this {
-    return super.on(event, listener);
-  }
-
-  off<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this {
-    return super.off(event, listener);
-  }
-}
-
-// Export a singleton instance
-export const mcpManager = new MCPManager();