imcp 0.0.16 → 0.0.17

package/src/core/onboard/FeedOnboardService.ts

@@ -1,18 +1,12 @@
-import { FeedConfiguration, McpConfig } from '../types.js';
-import { configProvider, ConfigurationProvider } from '../ConfigurationProvider.js';
+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 } from '../../utils/logger.js';
-import { OnboardStatus, OnboardingProcessStatus, OperationStatus, OperationType, ValidationOperationResult } from './OnboardStatus.js';
+import { OnboardingProcessStatus, OperationStatus, OperationType, ValidationOperationResult } from './OnboardStatus.js';
 import { onboardStatusManager } from './OnboardStatusManager.js';
 import { onboardProcessor } from './OnboardProcessor.js';
 
-const NON_COMPLETED_ONBOARDING_STATUSES: OnboardingProcessStatus[] = [
-  OnboardingProcessStatus.PENDING,
-  OnboardingProcessStatus.VALIDATING,
-  OnboardingProcessStatus.VALIDATED,
-  OnboardingProcessStatus.PR_CREATING,
-];
-
 /**
  * Service for handling feed onboarding operations
  */
@@ -23,17 +17,53 @@ export class FeedOnboardService {
     // 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
    * @param config Feed configuration to onboard
    */
   public async onboardFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
     // Perform static validation first
-    await this.validateStaticConfig(config, forExistingCategory);
-
-    const operationStatus = await this._initiateOperation(config, 'FULL_ONBOARDING', forExistingCategory);
+    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
+      return {
+        onboardingId: onboardingId,
+        status: OnboardingProcessStatus.FAILED, // Or a new status like 'VALIDATION_REQUIRED'
+        message: 'The feed configuration has not been validated or has changed. Please validate the configuration before publishing.',
+        lastQueried: new Date().toISOString(),
+        feedConfiguration: config
+      };
+    }
 
-    return { ...operationStatus, 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
+    };
   }
 
   /**
@@ -43,9 +73,9 @@ export class FeedOnboardService {
    */
   public async validateFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
     // Perform static validation first
-    await this.validateStaticConfig(config, forExistingCategory);
+    const serverList = await this.validateStaticConfig(config, forExistingCategory);
 
-    const operationStatus = await this._initiateOperation(config, 'VALIDATION_ONLY', forExistingCategory);
+    const operationStatus = await this._initiateOperation(config, 'VALIDATION_ONLY', serverList, forExistingCategory);
 
     return { ...operationStatus, feedConfiguration: config };
   }
@@ -56,59 +86,85 @@ export class FeedOnboardService {
    * 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, forExistingCategory?: boolean): Promise<OperationStatus> {
-    let existingOperation = await this._findExistingNonCompletedOperation(config.name, operationType);
+  private async _initiateOperation(config: FeedConfiguration, operationType: OperationType, serverList: string[], forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
+    // First, check for existing non-completed operations
+    let existingOperation = await onboardStatusManager._findExistingNonCompletedOperation(config.name, operationType);
 
     if (existingOperation) {
-      // OnboardStatus has a lastUpdated field (ISO string)
-      // This field is updated by OnboardStatusManager.updateStatus
       const fiveMinutesInMs = 5 * 60 * 1000;
       const lastUpdateTimestamp = existingOperation.lastUpdated ? new Date(existingOperation.lastUpdated).getTime() : 0;
       const currentTime = new Date().getTime();
 
       if (lastUpdateTimestamp > 0 && (currentTime - lastUpdateTimestamp) > fiveMinutesInMs) {
         Logger.log(`WARNING: [${existingOperation.onboardingId}] Found stale ${operationType} operation for feed: ${config.name} (last updated at: ${existingOperation.lastUpdated}). Proceeding to create a new operation.`);
-
         existingOperation = undefined; // Treat as no existing operation for starting a new one
       } else {
         Logger.log(`[${existingOperation.onboardingId}] Found existing non-completed ${operationType} operation for feed: ${config.name}. Returning its status.`);
+        const lastStep = existingOperation.steps && existingOperation.steps.length > 0 ? existingOperation.steps[existingOperation.steps.length - 1].stepName : 'N/A';
         return {
           onboardingId: existingOperation.onboardingId,
           status: existingOperation.status,
-          message: `An ${operationType} process for this feed (${existingOperation.onboardingId}) is already in status: ${existingOperation.status}. Current step: ${existingOperation.currentStep || 'N/A'}`,
+          message: `An ${operationType} process for this feed (${existingOperation.onboardingId}) is already in status: ${existingOperation.status}. Last step: ${lastStep}`,
           lastQueried: new Date().toISOString(),
         };
       }
     }
 
-    // serverName is removed
+    // Then, 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);
-    const onboardingId = initialStatus.onboardingId;
 
-    await onboardStatusManager.saveFeedConfiguration(onboardingId, config);
+    // Use config.name as categoryName for saveFeedConfiguration
+    await onboardStatusManager.saveFeedConfiguration(config.name, operationType, config);
 
     if (operationType === 'FULL_ONBOARDING') {
-      this.processFullOnboarding(onboardingId, config).catch(async (error) => {
+      // 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.updateStatus(onboardingId, {
-          status: OnboardingProcessStatus.FAILED,
-          errorMessage: error instanceof Error ? error.message : String(error),
-          currentStep: 'Failed during full onboarding process',
-          prInfo: undefined,
-        });
+        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).catch(async (error) => {
+      this.processValidationOnly(onboardingId, config, operationType, serverList).catch(async (error) => {
         Logger.error(`[${onboardingId}] Feed validation process failed:`, error);
-        await onboardStatusManager.updateStatus(onboardingId, {
-          status: OnboardingProcessStatus.FAILED,
-          errorMessage: error instanceof Error ? error.message : String(error),
-          currentStep: 'Failed during validation process',
-          validationStatus: (error as any).validationStatus || { isValid: false, message: error instanceof Error ? error.message : String(error) },
-          prInfo: undefined,
-        });
+        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
+        );
       });
     }
 
@@ -120,33 +176,14 @@ export class FeedOnboardService {
     };
   }
 
-  /**
-   * Finds an existing non-completed operation for a given feed name, server name, and operation type.
-   * @param feedName The name of the feed.
-   * @param operationType The type of operation.
-   * @returns A promise that resolves to the OnboardStatus of the existing operation, or undefined if not found.
-   */
-  private async _findExistingNonCompletedOperation(
-    feedName: string,
-    operationType: OperationType
-  ): Promise<OnboardStatus | undefined> {
-    const allStatuses = await onboardStatusManager.getAllStatuses();
-    return Object.values(allStatuses).find(
-      (status) =>
-        status.feedName === feedName &&
-        // status.serverName === serverName && // serverName is removed
-        status.operationType === operationType &&
-        NON_COMPLETED_ONBOARDING_STATUSES.includes(status.status)
-    );
-  }
-
   /**
    * 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<void> {
+  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.');
@@ -163,30 +200,63 @@ export class FeedOnboardService {
     // --- 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.`);
       }
-      // Original logic from existing validateStaticConfig:
-      // This implies that for an existing category, the payload must define mcpServers,
-      // and at least one of them must be new.
-      // If config.mcpServers is empty, newServersInPayload.length will be 0, leading to an error.
+      // 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));
-      const newServersInPayload = config.mcpServers.filter((s: McpConfig) => !existingServerNames.has(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 (newServersInPayload.length === 0) {
-        // This error triggers if config.mcpServers is empty, or if all servers in config.mcpServers already exist.
-        throw new Error('No new servers provided for the existing category. Ensure the "mcpServers" list in your payload contains at least one server not already in this category, or that the list is not empty if you intend to add servers.');
+      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) {
-        throw new Error(`Category "${config.name}" already exists. To modify an existing category, please indicate that it is for an existing category.`);
+        // 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;
   }
 
   /**
@@ -194,59 +264,67 @@ export class FeedOnboardService {
    * 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): Promise<void> {
-    await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.VALIDATING, currentStep: 'Validating feed configuration' });
+  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 {
-      feedValidator.validate(config);
-
-      // Then, validate each MCP server
-      for (const server of config.mcpServers) {
+      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(server, config);
-          overallValidationStatus.serverResults?.push({ serverName: server.name, isValid: true });
-          await onboardStatusManager.updateStatus(onboardingId, {
-            currentStep: `Validated server: ${server.name}`,
-            validationStatus: overallValidationStatus // Update with intermediate results
-          });
+          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: server.name,
+            serverName: serverConfig.name,
             isValid: false,
             message: serverValidationError.message || String(serverValidationError)
           });
-          // Update status immediately upon first server validation failure
-          await onboardStatusManager.updateStatus(onboardingId, {
-            status: OnboardingProcessStatus.FAILED,
-            currentStep: `Validation failed for server: ${server.name}`,
-            errorMessage: `Server ${server.name}: ${serverValidationError.message || String(serverValidationError)}`,
-            validationStatus: overallValidationStatus
-          });
+          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 servers validated successfully
-      await onboardStatusManager.updateStatus(onboardingId, {
-        status: OnboardingProcessStatus.VALIDATED,
-        currentStep: 'All servers in feed configuration validated successfully',
-        validationStatus: overallValidationStatus
-      });
+      // 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
-      // This block will now primarily catch errors from the main feedValidator.validate(config)
-      // or if a server validation error was re-thrown and not caught by the loop's catch.
-      await onboardStatusManager.updateStatus(onboardingId, {
-        status: OnboardingProcessStatus.FAILED,
-        currentStep: 'Feed configuration validation failed',
-        errorMessage: validationError.message || String(error),
-        validationStatus: { // Ensure this reflects the actual state, potentially including partial server results
+      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 // Include any server results gathered so far
+          serverResults: overallValidationStatus.serverResults // Ensure this is up-to-date
         }
       });
       throw error; // Re-throw to be caught by the calling process
@@ -259,29 +337,37 @@ export class FeedOnboardService {
    * 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, forExistingCategory?: boolean): Promise<void> {
+  private async processValidationOnly(onboardingId: string, config: FeedConfiguration, operationType: OperationType, serverList: string[]): Promise<void> {
     try {
-      await this._validateFeedConfiguration(onboardingId, config);
-      // _validateFeedConfiguration now handles setting VALIDATED or FAILED.
-      // If it completes without throwing, it means validation was successful.
-      const finalStatus = await onboardStatusManager.getStatus(onboardingId);
+      // 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: [] }, // Get the detailed status
+        validationStatus: finalStatus?.validationStatus || { isValid: true, serverResults: [] },
         feedConfiguration: config
       };
-      await onboardStatusManager.updateStatus(onboardingId, {
-        status: OnboardingProcessStatus.SUCCEEDED, // Mark as SUCCEEDED for VALIDATION_ONLY
-        currentStep: 'Feed configuration validated successfully',
-        errorMessage: undefined,
-        prInfo: undefined,
-        result: result
+      // 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}`);
     } catch (error) {
-      // Error handling is done within _validateFeedConfiguration and by the caller of processValidationOnly
-      Logger.error(`[${onboardingId}] Feed validation process failed for ${config.name}:`, error);
-      // No need to re-throw here as the caller's catch block will handle it.
+      // 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);
     }
   }
 
@@ -292,52 +378,90 @@ export class FeedOnboardService {
    * 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, forExistingCategory?: boolean): Promise<void> {
+  private async processFullOnboarding(onboardingId: string, config: FeedConfiguration, operationType: OperationType, serverList: string[]): Promise<void> {
     const { tempDir, repoDir } = onboardProcessor.createDirectories(onboardingId);
     try {
-      await this._validateFeedConfiguration(onboardingId, config);
+      // 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.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Forking repository' });
+      await onboardStatusManager.recordStep(config.name, operationType, 'Forking repository', undefined, OnboardingProcessStatus.PR_CREATING);
       await onboardProcessor.forkRepo(onboardingId, repoDir);
 
-      await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Cloning repository' });
+      await onboardStatusManager.recordStep(config.name, operationType, 'Cloning repository', undefined, OnboardingProcessStatus.PR_CREATING);
       await onboardProcessor.cloneRepo(onboardingId, tempDir, repoDir);
 
-      await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Setting up branch' });
+      await onboardStatusManager.recordStep(config.name, operationType, 'Setting up branch', undefined, OnboardingProcessStatus.PR_CREATING);
       const branchName = await onboardProcessor.setupBranch(onboardingId, config, repoDir);
 
-      await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Saving feed configuration to repository' });
-      await onboardProcessor.saveFeedConfigToRepo(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.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Creating pull request' });
+      await onboardStatusManager.recordStep(config.name, operationType, 'Creating pull request', undefined, OnboardingProcessStatus.PR_CREATING);
       const prInfo = await onboardProcessor.createPullRequest(onboardingId, config, repoDir, branchName);
 
-      await onboardStatusManager.updateStatus(onboardingId, {
-        status: OnboardingProcessStatus.SUCCEEDED,
-        currentStep: 'Successfully onboarded',
-        errorMessage: undefined,
+      // 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
+        result: prInfo.url // Store PR URL as the result
       });
-      Logger.log(`[${onboardingId}] Successfully onboarded feed: ${config.name}`);
+      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}`);
+      } 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 failed:`, error);
+      Logger.error(`[${onboardingId}] Full feed onboarding process failed:`, error);
       const errorMessage = error instanceof Error ? error.message : String(error);
-      let currentStep = 'Failed during full onboarding process';
-      if (error instanceof Error && 'step' in error) {
-        currentStep = `Failed at step: ${error.step}`;
-      } else if ((await onboardStatusManager.getStatus(onboardingId))?.currentStep?.includes('validation failed')) {
-        throw error;
-      }
 
-      await onboardStatusManager.updateStatus(onboardingId, {
-        status: OnboardingProcessStatus.FAILED,
-        errorMessage: errorMessage,
-        currentStep: currentStep,
-      });
-      throw error;
+      // 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.
     }
   }
 }