imcp 0.1.7 → 0.1.8-dev

package/src/core/onboard/FeedOnboardService.ts

@@ -1,501 +0,0 @@
-import { FeedConfiguration, McpConfig } from '../metadatas/types.js';
-import { configProvider } from '../loaders/ConfigurationProvider.js';
-import { ServerSchemaProvider } from '../loaders/ServerSchemaProvider.js';
-import { feedValidator } from '../validators/FeedValidator.js';
-import { Logger, EventType, EventStatus } from '../../utils/logger.js';
-import { OnboardingProcessStatus, OperationStatus, OperationType, ValidationOperationResult } from './OnboardStatus.js';
-import { onboardStatusManager } from './OnboardStatusManager.js';
-import { onboardProcessor } from './OnboardProcessor.js';
-
-/**
- * Service for handling feed onboarding operations
- */
-export class FeedOnboardService {
-  // tempDir and repoDir will be generated per onboarding process
-
-  constructor() {
-    // No shared tempDir or repoDir at instance level
-  }
-
-  /**
-   * Creates an operation ID that combines feed name and operation type.
-   * @param feedName The name of the feed.
-   * @param operationType The type of operation.
-   * @returns Combined operation ID string.
-   */
-  private createOperationId(feedName: string, operationType: OperationType): string {
-    return `${feedName}_${operationType}`;
-  }
-
-  /**
-   * Onboard a new feed configuration. This method performs validation and initiates the onboarding process.
-   * @param config Feed configuration to onboard
-   * @param forExistingCategory Whether this onboarding is for an existing category
-   * @returns Promise resolving to operation status with optional feed configuration
-   */
-  public async onboardFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
-    // Perform static validation first
-    const serverList = await this.validateStaticConfig(config, forExistingCategory);
-
-    // Check for an existing, succeeded VALIDATION_ONLY operation with an identical configuration.
-    const existingSucceededValidation = await onboardStatusManager.findSucceededOperation(config.name, 'VALIDATION_ONLY', config);
-
-    if (!existingSucceededValidation) {
-      // If no matching successful validation is found, instruct user to validate first.
-      Logger.log(`Feed ${config.name} has not been successfully validated with the current configuration. Publishing requires prior successful validation.`);
-      // Return a specific status/message indicating validation is required.
-      // This is not a FAILED state for an operation, but a prerequisite not met.
-      // We'll use a custom message and potentially a specific status if we define one for "PREREQUISITE_FAILED" or similar.
-      // For now, let's return a FAILED status for the attempted FULL_ONBOARDING initiation.
-      // A more robust solution might involve a different return type or error code.
-      const onboardingId = this.createOperationId(config.name, 'FULL_ONBOARDING'); // Hypothetical ID
-      const errorMessage = `No prior successful validation found for feed: ${config.name}. Please validate the configuration before publishing.`;
-      
-      // Track failed event
-      Logger.trackEvent(EventType.FEED_ONBOARD, {
-        status: EventStatus.FAILED,
-        feedName: config.name,
-        errorMessage,
-        onboardingId: onboardingId,
-        feedConfiguration: config
-      });
-      
-      return {
-        onboardingId: onboardingId,
-        status: OnboardingProcessStatus.FAILED, // Or a new status like 'VALIDATION_REQUIRED'
-        message: errorMessage,
-        lastQueried: new Date().toISOString(),
-        feedConfiguration: config
-      };
-    }
-
-    Logger.log(`Found existing successful validation for feed: ${config.name}. Proceeding with full onboarding.`);
-    // If validation exists and matches, proceed to initiate FULL_ONBOARDING.
-    // _initiateOperation will handle checks for existing non-completed or successfully completed FULL_ONBOARDING operations.
-    const operationStatus = await this._initiateOperation(config, 'FULL_ONBOARDING', serverList, forExistingCategory);
-
-    return {
-      ...operationStatus,
-      feedConfiguration: config
-    };
-  }
-
-  /**
-   * Validate a feed configuration without performing full onboarding.
-   * This method performs static validation and initiates the validation process.
-   * @param config Feed configuration to validate
-   * @param forExistingCategory Whether this validation is for an existing category
-   * @returns Promise resolving to operation status with optional feed configuration
-   */
-  public async validateFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
-    // Perform static validation first
-    const serverList = await this.validateStaticConfig(config, forExistingCategory);
-
-    const operationStatus = await this._initiateOperation(config, 'VALIDATION_ONLY', serverList, forExistingCategory);
-
-    return { ...operationStatus, feedConfiguration: config };
-  }
-
-  /**
-   * Initiates either a full onboarding or a validation-only operation.
-   * It checks for existing non-completed operations for the same feed and operation type.
-   * If an existing operation is found, its status is returned. Otherwise, a new operation is created and started.
-   * @param config The feed configuration.
-   * @param operationType The type of operation to initiate (FULL_ONBOARDING or VALIDATION_ONLY).
-   * @param serverList The list of server names to process.
-   * @returns A promise that resolves to the operation status.
-   */
-  private async _initiateOperation(config: FeedConfiguration, operationType: OperationType, serverList: string[], forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
-    // Check for successful operations with matching configuration
-    const succeededOperation = await onboardStatusManager.findSucceededOperation(config.name, operationType, config);
-    if (succeededOperation) {
-      Logger.log(`[${succeededOperation.onboardingId}] Found existing successful ${operationType} operation for feed: ${config.name} with matching configuration.`);
-      const operationStatus: OperationStatus & { feedConfiguration?: FeedConfiguration } = {
-        onboardingId: succeededOperation.onboardingId,
-        status: succeededOperation.status,
-        message: `A successful ${operationType} already exists for this feed with identical configuration.`,
-        lastQueried: new Date().toISOString(),
-      };
-
-      if (config) {
-        operationStatus.feedConfiguration = config;
-      }
-
-      return operationStatus;
-    }
-
-    // If no existing or matching operations found, create a new one
-    const onboardingId = this.createOperationId(config.name, operationType);
-    const initialStatus = await onboardStatusManager.createInitialStatus(config.name, operationType);
-
-    // Use config.name as categoryName for saveFeedConfiguration
-    await onboardStatusManager.saveFeedConfiguration(config.name, operationType, config);
-
-    if (operationType === 'FULL_ONBOARDING') {
-      // For FULL_ONBOARDING, we assume all servers defined in the config are to be processed for PR creation.
-      // The serverList from validateStaticConfig primarily influences validation.
-      // If specific servers need to be excluded from the PR, this logic might need adjustment.
-      this.processFullOnboarding(onboardingId, config, operationType, serverList).catch(async (error) => {
-        Logger.error(`[${onboardingId}] Full feed onboarding process failed:`, error);
-        await onboardStatusManager.recordStep(
-          config.name,
-          operationType,
-          'Failed during full onboarding process',
-          undefined, // serverName
-          OnboardingProcessStatus.FAILED,
-          error instanceof Error ? error.message : String(error)
-        );
-      });
-    } else if (operationType === 'VALIDATION_ONLY') {
-      this.processValidationOnly(onboardingId, config, operationType, serverList).catch(async (error) => {
-        Logger.error(`[${onboardingId}] Feed validation process failed:`, error);
-        await onboardStatusManager.recordStep(
-          config.name,
-          operationType,
-          'Failed during validation process',
-          undefined, // serverName
-          OnboardingProcessStatus.FAILED,
-          error instanceof Error ? error.message : String(error)
-          // TODO: Consider how to best store/pass 'validationStatus' if it's still needed at this specific failure point
-        );
-      });
-    }
-
-    return {
-      onboardingId,
-      status: OnboardingProcessStatus.PENDING,
-      message: `New ${operationType} process started with ID: ${onboardingId}.`,
-      lastQueried: new Date().toISOString(),
-    };
-  }
-
-  /**
-   * Performs static validation of the feed configuration.
-   * @param config The feed configuration to validate.
-   * @param forExistingCategory Whether this is for an existing category.
-   * @returns A promise that resolves to a list of server names to be processed.
-   * @throws Error if validation fails.
-   */
-  private async validateStaticConfig(config: FeedConfiguration, forExistingCategory?: boolean): Promise<string[]> {
-    // --- Start of moved and enhanced static validation ---
-    if (!config || typeof config !== 'object') { // Check if config itself is a valid object
-      throw new Error('Invalid configuration: Input must be a valid object.');
-    }
-    if (typeof config.name !== 'string' || !config.name.trim()) {
-      throw new Error('Invalid configuration: "name" must be a non-empty string.');
-    }
-    if (!Array.isArray(config.requirements)) {
-      throw new Error('Invalid configuration: "requirements" must be an array.');
-    }
-    if (!Array.isArray(config.mcpServers)) {
-      throw new Error('Invalid configuration: "mcpServers" must be an array.');
-    }
-    // --- End of moved static validation ---
-
-    const existingConfig = await configProvider.getFeedConfiguration(config.name);
-    // Note: operationType validation is handled at the MCP server level
-
-    let serverListToProcess: string[];
-
-    if (forExistingCategory) {
-      if (!existingConfig) {
-        throw new Error(`Cannot update non-existent category: ${config.name}. Please ensure the category name is correct or create it as a new category.`);
-      }
-      // For existing categories, mcpServers list must be present in the payload.
-      if (!config.mcpServers || config.mcpServers.length === 0) {
-        throw new Error('For an existing category, "mcpServers" must be provided and non-empty in the payload.');
-      }
-
-      const existingServerNames = new Set(existingConfig.mcpServers.map((s: McpConfig) => s.name));
-      // Servers to process are those that are new OR existing ones marked as adhoc in the payload.
-      const serversToProcessInPayload = config.mcpServers.filter(payloadServer => {
-        const isNew = !existingServerNames.has(payloadServer.name);
-        const isAdhocInPayload = payloadServer.systemTags?.adhoc === 'true';
-        return isNew || (existingServerNames.has(payloadServer.name) && isAdhocInPayload);
-      });
-
-      if (serversToProcessInPayload.length === 0) {
-        // If no new or editable (adhoc) servers are found in the payload for an existing category, it's an error.
-        throw new Error(`No new or adhoc (editable) servers provided for the existing category "${config.name}". Ensure the "mcpServers" list in your payload contains at least one server not already in this category or an existing server marked with adhoc:true.`);
-      }
-      serverListToProcess = serversToProcessInPayload.map(s => s.name);
-    } else { // For new categories
-      if (existingConfig) {
-        // If it's not for an existing category, but the category name already exists, this is an error.
-        // Adhoc tags on servers are not relevant here as we are creating a new category.
-        throw new Error(`Category "${config.name}" already exists. To modify an existing category, please set 'forExistingCategory' to true.`);
-      }
-      // For new categories, mcpServers list must be present and non-empty.
-      if (!config.mcpServers || config.mcpServers.length === 0) {
-        throw new Error('Server configuration ("mcpServers") must be provided and non-empty for new categories.');
-      }
-      // For new categories, all servers in the payload are considered.
-      serverListToProcess = config.mcpServers.map(s => s.name);
-    }
-    // Remove systemTags from individual servers
-    if (config.mcpServers && Array.isArray(config.mcpServers)) {
-      config.mcpServers.forEach(server => {
-        if (server.systemTags) {
-          delete server.systemTags;
-        }
-      });
-    }
-
-    // Remove systemTags and PullRequest from the main config object
-    if (config.systemTags) {
-      delete config.systemTags;
-    }
-    if (config.PullRequest) {
-      delete config.PullRequest;
-    }
-
-    return serverListToProcess;
-  }
-
-  /**
-   * Validates the feed configuration.
-   * Updates the onboarding status to VALIDATING, then to VALIDATED or FAILED based on the validation result.
-   * @param onboardingId The ID of the onboarding process.
-   * @param config The feed configuration to validate.
-   * @param operationType The type of operation this validation is for.
-   * @param serverList The list of server names to validate.
-   * @throws Error if validation fails, to be caught by the calling process.
-   */
-  private async _validateFeedConfiguration(onboardingId: string, config: FeedConfiguration, operationType: OperationType, serverList: string[]): Promise<void> {
-    await onboardStatusManager.recordStep(config.name, operationType, 'Validating feed configuration', undefined, OnboardingProcessStatus.VALIDATING);
-    let overallValidationStatus: ValidationOperationResult['validationStatus'] = { isValid: true, serverResults: [] };
-    try {
-      await feedValidator.validate(config, config.name, operationType);
-
-      // Then, validate each MCP server specified in the serverList
-      for (const serverConfig of config.mcpServers) {
-        if (!serverList.includes(serverConfig.name)) {
-          Logger.log(`[${onboardingId}] Skipping validation for server ${serverConfig.name} as it's not in the specified list for this operation.`);
-          // Optionally, record a skipped status or add to serverResults as skipped
-          overallValidationStatus.serverResults?.push({ serverName: serverConfig.name, isValid: true, message: "Skipped (existed)" });
-          continue;
-        }
-        try {
-          await feedValidator.validateServer(serverConfig, config, config.name, operationType);
-          overallValidationStatus.serverResults?.push({ serverName: serverConfig.name, isValid: true });
-          await onboardStatusManager.recordStep(config.name, operationType, `Validated server: ${serverConfig.name}`, serverConfig.name, OnboardingProcessStatus.VALIDATING);
-          await onboardStatusManager.updateStatus(config.name, operationType, { validationStatus: overallValidationStatus });
-        } catch (serverValidationError: any) {
-          overallValidationStatus.isValid = false;
-          overallValidationStatus.serverResults?.push({
-            serverName: serverConfig.name,
-            isValid: false,
-            message: serverValidationError.message || String(serverValidationError)
-          });
-          await onboardStatusManager.recordStep(
-            config.name,
-            operationType,
-            `Validation failed for server: ${serverConfig.name}`,
-            serverConfig.name,
-            OnboardingProcessStatus.FAILED,
-            `Server ${serverConfig.name}: ${serverValidationError.message || String(serverValidationError)}`
-          );
-          await onboardStatusManager.updateStatus(config.name, operationType, { validationStatus: overallValidationStatus });
-          throw serverValidationError; // Propagate the error to fail the whole validation
-        }
-      }
-
-      // If all *processed* servers validated successfully
-      await onboardStatusManager.recordStep(config.name, operationType, 'All servers in feed configuration validated successfully', undefined, OnboardingProcessStatus.VALIDATED);
-      await onboardStatusManager.updateStatus(config.name, operationType, { validationStatus: overallValidationStatus });
-    } catch (error) {
-      const validationError = error as any; // Assuming error might have validation details
-      await onboardStatusManager.recordStep(
-        config.name,
-        operationType,
-        'Feed configuration validation failed',
-        undefined,
-        OnboardingProcessStatus.FAILED,
-        validationError.message || String(error)
-      );
-      await onboardStatusManager.updateStatus(config.name, operationType, {
-        validationStatus: {
-          isValid: false,
-          message: validationError.message || String(error),
-          serverResults: overallValidationStatus.serverResults // Ensure this is up-to-date
-        }
-      });
-      throw error; // Re-throw to be caught by the calling process
-    }
-  }
-
-  /**
-   * Processes a validation-only operation for a feed configuration.
-   * It validates the configuration and updates the status to SUCCEEDED if validation is successful.
-   * If validation fails, the error is handled by _validateFeedConfiguration and the calling _initiateOperation method.
-   * @param onboardingId The ID of the onboarding process.
-   * @param config The feed configuration.
-   * @param operationType The type of operation (should be 'VALIDATION_ONLY').
-   * @param serverList The list of server names to validate.
-   */
-  private async processValidationOnly(onboardingId: string, config: FeedConfiguration, operationType: OperationType, serverList: string[]): Promise<void> {
-    try {
-      // Pass operationType and serverList to _validateFeedConfiguration
-      await this._validateFeedConfiguration(onboardingId, config, operationType, serverList);
-      // Use config.name and operationType for getStatus
-      const finalStatus = await onboardStatusManager.getStatus(config.name, operationType);
-      const result: ValidationOperationResult = {
-        validationStatus: finalStatus?.validationStatus || { isValid: true, serverResults: [] },
-        feedConfiguration: config
-      };
-      // Use config.name and operationType for recordStep and updateStatus
-      await onboardStatusManager.recordStep(
-        config.name,
-        operationType,
-        'Feed configuration validated successfully',
-        undefined, // serverName
-        OnboardingProcessStatus.SUCCEEDED
-      );
-      await onboardStatusManager.updateStatus(config.name, operationType, {
-        errorMessage: undefined, // Clear any previous error
-        prInfo: undefined, // Clear PR info for validation-only
-        result: result, // Set the result
-        validationStatus: result.validationStatus // Ensure validationStatus is also updated on success
-      });
-      Logger.log(`[${onboardingId}] Successfully validated feed: ${config.name}`);
-
-      // Track successful validation
-      Logger.trackEvent(EventType.FEED_VALIDATE, {
-        status: EventStatus.SUCCESS,
-        feedName: config.name,
-        operationType: 'VALIDATION_ONLY',
-        onboardingId: onboardingId,
-        feedConfiguration: config
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      // Error is already logged and status updated by _validateFeedConfiguration or its callers
-      Logger.error(`[${onboardingId}] Feed validation process failed for ${config.name} (already handled):`, error);
-      
-      // Track validation failure
-      Logger.trackEvent(EventType.FEED_VALIDATE, {
-        status: EventStatus.FAILED,
-        feedName: config.name,
-        operationType: 'VALIDATION_ONLY',
-        errorMessage: errorMessage,
-        onboardingId: onboardingId,
-        feedConfiguration: config
-      });
-    }
-  }
-
-
-  /**
-   * Processes the full onboarding for a feed configuration.
-   * This includes validation, forking/cloning the repository, saving the config, and creating a pull request.
-   * Manages status updates throughout the process and handles cleanup of temporary directories.
-   * @param onboardingId The ID of the onboarding process.
-   * @param config The feed configuration.
-   * @param operationType The type of operation (should be 'FULL_ONBOARDING').
-   * @throws Error if any step of the full onboarding process fails.
-   */
-  private async processFullOnboarding(onboardingId: string, config: FeedConfiguration, operationType: OperationType, serverList: string[]): Promise<void> {
-    const { tempDir, repoDir } = onboardProcessor.createDirectories(onboardingId);
-    try {
-      // Validation is now a prerequisite and assumed to be done if this process is initiated.
-      // The status should be PENDING or a similar initial state from _initiateOperation.
-      // We directly proceed to PR creation steps.
-      // The first step recorded here will likely move status from PENDING to PR_CREATING.
-
-      await onboardStatusManager.recordStep(config.name, operationType, 'Starting PR creation process (validation confirmed)', undefined, OnboardingProcessStatus.PR_CREATING);
-
-      await onboardStatusManager.recordStep(config.name, operationType, 'Forking repository', undefined, OnboardingProcessStatus.PR_CREATING);
-      await onboardProcessor.forkRepo(onboardingId, repoDir);
-
-      await onboardStatusManager.recordStep(config.name, operationType, 'Cloning repository', undefined, OnboardingProcessStatus.PR_CREATING);
-      await onboardProcessor.cloneRepo(onboardingId, tempDir, repoDir);
-
-      await onboardStatusManager.recordStep(config.name, operationType, 'Setting up branch', undefined, OnboardingProcessStatus.PR_CREATING);
-      const branchName = await onboardProcessor.setupBranch(onboardingId, config, repoDir);
-
-      await onboardStatusManager.recordStep(config.name, operationType, 'Saving feed configuration to repository', undefined, OnboardingProcessStatus.PR_CREATING);
-      const { feedFilePath, categorySchemasPath } = await onboardProcessor.saveFeedConfigToRepo(onboardingId, config, repoDir, serverList);
-
-      await onboardStatusManager.recordStep(config.name, operationType, 'Creating pull request', undefined, OnboardingProcessStatus.PR_CREATING);
-      const prInfo = await onboardProcessor.createPullRequest(onboardingId, config, repoDir, branchName);
-
-      // Step 3: Finalize with SUCCEEDED status for PR creation
-      await onboardStatusManager.recordStep(config.name, operationType, prInfo.prExists ? 'Successfully updated to existing pull request' : 'Successfully created pull request', undefined, OnboardingProcessStatus.SUCCEEDED);
-      await onboardStatusManager.updateStatus(config.name, operationType, {
-        errorMessage: undefined, // Clear any previous errors
-        prInfo: prInfo,
-        result: prInfo.url // Store PR URL as the result
-      });
-      Logger.log(`[${onboardingId}] Successfully created/updated PR for feed: ${config.name}. PR URL: ${prInfo.url}`);
-
-      // After successful PR, re-initialize providers
-      try {
-        await onboardStatusManager.recordStep(config.name, operationType, 'Reloading server schemas', undefined, OnboardingProcessStatus.SUCCEEDED);
-        Logger.log(`[${onboardingId}] Initializing ServerSchemaProvider with new schemas at ${categorySchemasPath}`);
-        await ServerSchemaProvider.getInstance().initialize(categorySchemasPath);
-        Logger.log(`[${onboardingId}] ServerSchemaProvider re-initialized.`);
-
-        await onboardStatusManager.recordStep(config.name, operationType, 'Reloading configurations', undefined, OnboardingProcessStatus.SUCCEEDED);
-        Logger.log(`[${onboardingId}] Initializing ConfigurationProvider with new feed file at ${feedFilePath}`);
-        await configProvider.initialize(feedFilePath, { prLink: prInfo.url, adhocServers: serverList }); // configProvider is already an instance
-        Logger.log(`[${onboardingId}] ConfigurationProvider re-initialized.`);
-
-        Logger.log(`[${onboardingId}] Successfully completed full onboarding for feed: ${config.name}`);
-
-        // Track successful onboarding
-        Logger.trackEvent(EventType.FEED_ONBOARD, {
-          status: EventStatus.SUCCESS,
-          feedName: config.name,
-          onboardingId: onboardingId,
-          prUrl: prInfo.url,
-          feedConfiguration: config
-        });
-      } catch (reinitError) {
-        Logger.warn(`[${onboardingId}] Failed to re-initialize providers after PR creation for feed ${config.name}:`);
-        Logger.warn(`Skipping re-initialization of providers due to error: ${reinitError}`,);
-      }
-
-    } catch (error) {
-      Logger.error(`[${onboardingId}] Full feed onboarding process failed:`, error);
-      const errorMessage = error instanceof Error ? error.message : String(error);
-
-      // Track onboarding failure
-      Logger.trackEvent(EventType.FEED_ONBOARD, {
-        status: EventStatus.FAILED,
-        feedName: config.name,
-        onboardingId: onboardingId,
-        errorMessage,
-        feedConfiguration: config
-      });
-
-      // Check if status is already FAILED (e.g., by _validateFeedConfiguration)
-      // to avoid overwriting a more specific error message or step from validation.
-      const currentStatus = await onboardStatusManager.getStatus(config.name, operationType);
-      if (currentStatus?.status !== OnboardingProcessStatus.FAILED) {
-        let stepName = 'Failed during full onboarding process';
-        if (error instanceof Error && 'step' in error && typeof error.step === 'string') {
-          stepName = `Failed at step: ${error.step}`;
-        } else if (currentStatus?.steps && currentStatus.steps.length > 0) {
-          // If not already failed by validation, use the last known good step before this error
-          stepName = `Failed after step: ${currentStatus.steps[currentStatus.steps.length - 1].stepName}`;
-        }
-        await onboardStatusManager.recordStep(
-          config.name,
-          operationType,
-          stepName,
-          undefined, // serverName
-          OnboardingProcessStatus.FAILED,
-          errorMessage
-        );
-      } else {
-        // If already FAILED, the error and step were likely recorded by _validateFeedConfiguration.
-        // Log the current error context if it's different or provides more info.
-        Logger.log(`[${onboardingId}] Process was already marked as FAILED. Additional context - Current error: ${errorMessage}. Initial error from status: ${currentStatus.errorMessage}`);
-      }
-      throw error; // Re-throw to ensure the promise from processFullOnboarding is rejected.
-    }
-  }
-}
-
-// Export singleton instance
-export const feedOnboardService = new FeedOnboardService();