imcp 0.0.16 → 0.0.17

package/src/core/onboard/OnboardProcessor.ts

@@ -2,8 +2,8 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs/promises';
 import path from 'path';
-import { GITHUB_REPO, SETTINGS_DIR } from '../constants.js';
-import { FeedConfiguration } from '../types.js';
+import { GITHUB_REPO, SETTINGS_DIR } from '../metadatas/constants.js';
+import { FeedConfiguration } from '../metadatas/types.js';
 import { Logger } from '../../utils/logger.js';
 
 const execAsync = promisify(exec);
@@ -110,16 +110,63 @@ export class OnboardProcessor {
      * @param onboardingId The ID of the onboarding process.
      * @param config The feed configuration to save.
      * @param repoDir The root directory of the cloned repository.
+     * @param serverList The list of MCP server names to process.
+     * @returns A promise that resolves to an object containing the path to the saved feed file and the category-specific schemas directory.
      * @throws An error if saving the configuration fails, with a 'step' property set to 'saveFeedConfigToRepo'.
      */
-    public async saveFeedConfigToRepo(onboardingId: string, config: FeedConfiguration, repoDir: string): Promise<void> {
+    public async saveFeedConfigToRepo(onboardingId: string, config: FeedConfiguration, repoDir: string, serverList: string[]): Promise<{ feedFilePath: string; categorySchemasPath: string; }> {
         try {
             const feedsDir = path.join(repoDir, GITHUB_REPO.feedsPath);
             await fs.mkdir(feedsDir, { recursive: true });
 
-            const configPath = path.join(feedsDir, `${config.name}.json`);
-            await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-            Logger.debug(`[${onboardingId}] Saved feed configuration to ${configPath}`);
+            const categoryName = config.name; // Feed name is the category name
+            const categorySchemasPath = path.join(feedsDir, 'schemas', categoryName);
+            await fs.mkdir(categorySchemasPath, { recursive: true }); // Ensure category schema directory exists
+
+            // Process schemas for each MCP server
+            // Create a mutable copy of mcpServers to update schema paths
+            const updatedMcpServers = [];
+            for (const server of config.mcpServers) {
+                if (!serverList.includes(server.name)) continue;
+                let updatedServer = { ...server }; // Shallow copy server config
+                if (updatedServer.schemas && typeof updatedServer.schemas === 'string' && updatedServer.schemas.trim() !== '') {
+                    const originalSchemaPath = updatedServer.schemas;
+                    const serverName = updatedServer.name;
+                    const newSchemaFileName = `${serverName}.json`;
+
+                    // Schemas are now directly under categorySchemasPath
+                    const newSchemaPathInRepo = path.join(categorySchemasPath, newSchemaFileName);
+
+                    try {
+                        // Read content from the original schema path
+                        const schemaContent = await fs.readFile(originalSchemaPath, 'utf-8');
+                        // Write content to the new schema file in the repo
+                        await fs.writeFile(newSchemaPathInRepo, schemaContent);
+                        Logger.debug(`[${onboardingId}] Copied schema for server '${serverName}' from '${originalSchemaPath}' to '${newSchemaPathInRepo}'`);
+
+                        // Update the schemas property to the new filename, as per instruction "rename schemas in McpServer as serverName].json"
+                        updatedServer.schemas = newSchemaFileName;
+                    } catch (schemaError) {
+                        const errorMsg = `Error processing schema for server '${serverName}' (source: ${originalSchemaPath}): ${schemaError instanceof Error ? schemaError.message : String(schemaError)}`;
+                        Logger.error(`[${onboardingId}] ${errorMsg}`);
+                        // Propagate the error to fail the onboarding step
+                        throw new Error(errorMsg);
+                    }
+                }
+                updatedMcpServers.push(updatedServer);
+            }
+
+            // Create a new config object with the updated mcpServers
+            const processedConfig = {
+                ...config,
+                mcpServers: updatedMcpServers
+            };
+ 
+            const feedFilePath = path.join(feedsDir, `${config.name}.json`);
+            await fs.writeFile(feedFilePath, JSON.stringify(processedConfig, null, 2));
+            Logger.debug(`[${onboardingId}] Saved feed configuration (with processed schemas) to ${feedFilePath}`);
+
+            return { feedFilePath, categorySchemasPath };
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             Logger.error(`[${onboardingId}] Error during saveFeedConfigToRepo: ${errorMessage}`);
@@ -160,7 +207,7 @@ export class OnboardProcessor {
             Logger.debug(`[${onboardingId}] Fetched from upstream.`);
 
             try {
-                await execAsync('git checkout main');
+                await execAsync('git checkout main --force');
                 Logger.debug(`[${onboardingId}] Switched to existing local branch 'main'.`);
             } catch (checkoutMainError: any) {
                 const errStdErr = checkoutMainError.stderr || '';
@@ -169,7 +216,7 @@ export class OnboardProcessor {
                     errStdErr.includes('pathspec \'main\' did not match any file(s) known to git')) {
                     Logger.debug(`[${onboardingId}] Local branch 'main' not found or invalid. Attempting to create it from 'upstream/main'.`);
                     try {
-                        await execAsync('git checkout -b main upstream/main');
+                        await execAsync('git checkout -b main --force upstream/main');
                         Logger.debug(`[${onboardingId}] Created and switched to local branch 'main' from 'upstream/main'.`);
                     } catch (createMainError: any) {
                         const errMsg = createMainError instanceof Error ? createMainError.message : String(createMainError);
@@ -221,7 +268,7 @@ export class OnboardProcessor {
      * @returns Object containing the PR URL and branch name.
      * @throws An error if PR creation fails.
      */
-    public async createPullRequest(onboardingId: string, config: FeedConfiguration, repoDir: string, branchName: string): Promise<{ url: string; branchName: string }> {
+    public async createPullRequest(onboardingId: string, config: FeedConfiguration, repoDir: string, branchName: string): Promise<{ url: string; branchName: string; prExists: boolean }> {
         try {
             process.chdir(repoDir);
 
@@ -251,19 +298,21 @@ export class OnboardProcessor {
             const username = await this.getGitHubUsername();
             const explicitHeadRef = `${username}:${branchName}`;
 
-            const prCheckCommand = `gh pr list --repo ${GITHUB_REPO.repoName} --head "${explicitHeadRef}" --state open --json url --limit 1`;
+            const prCheckCommand = `gh pr list --repo ${GITHUB_REPO.repoName} --head ${branchName} --author ${username} --state open --json url --limit 1`;
             Logger.debug(`[${onboardingId}] Checking for existing PR with command: ${prCheckCommand}`);
             const { stdout: existingPrJson } = await execAsync(prCheckCommand);
 
             let prUrlToReturn: string;
 
             const createPRCommand = `gh pr create --repo ${GITHUB_REPO.repoName} --base main --head ${explicitHeadRef} --title "${title}" --body "${body}"`
+            let prExists = false;
 
             if (existingPrJson && existingPrJson.trim() !== '[]' && existingPrJson.trim() !== '') {
                 try {
                     const prs = JSON.parse(existingPrJson);
                     if (prs.length > 0 && prs[0].url) {
                         prUrlToReturn = prs[0].url;
+                        prExists = true;
                         Logger.log(`[${onboardingId}] Found existing open PR for ${explicitHeadRef} on ${GITHUB_REPO.repoName}: ${prUrlToReturn}`);
                     } else {
                         Logger.debug(`[${onboardingId}] No existing PR found or unable to parse PR list JSON. Proceeding to create PR.`);
@@ -282,7 +331,7 @@ export class OnboardProcessor {
             }
 
             Logger.debug(`[${onboardingId}] Pull request operation completed. PR URL: ${prUrlToReturn}`);
-            return { url: prUrlToReturn, branchName };
+            return { url: prUrlToReturn, branchName: branchName, prExists: prExists };
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             Logger.error(`[${onboardingId}] Error during createPullRequest: ${errorMessage}`);

package/src/core/onboard/OnboardStatus.ts

@@ -1,4 +1,4 @@
-import { FeedConfiguration } from "../types.js";
+import { FeedConfiguration } from "../metadatas/types.js";
 
 export enum OnboardingProcessStatus {
   VALIDATING = 'validating',
@@ -20,7 +20,12 @@ export interface ServerValidationResult {
 export interface OnboardStatus {
   onboardingId: string;
   status: OnboardingProcessStatus;
-  currentStep?: string; // e.g., "Validating feed configuration", "Forking repository"
+  steps?: {
+    stepName: string;
+    timestamp: string;
+    status?: OnboardingProcessStatus; // Status of this specific step, if different from overall
+    errorMessage?: string;
+  }[];
   validationStatus?: {
     isValid: boolean;
     message?: string;

package/src/core/onboard/OnboardStatusManager.ts

@@ -1,17 +1,24 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { SETTINGS_DIR } from '../constants.js';
-import { FeedConfiguration } from '../types.js';
+import { SETTINGS_DIR } from '../metadatas/constants.js';
+import { FeedConfiguration, McpConfig } from '../metadatas/types.js';
 import { OnboardStatus, OnboardingProcessStatus, OperationType } from './OnboardStatus.js';
 import { Logger } from '../../utils/logger.js';
 
 const ONBOARD_STATUS_DIR = path.join(SETTINGS_DIR, 'onboard');
-const CATEGORY_OPERATIONS_STATUS_FILE = path.join(ONBOARD_STATUS_DIR, 'category_operations_status.json');
+const CATEGORY_OPERATIONS_STATUS_FILE = path.join(ONBOARD_STATUS_DIR, 'OnboardStatus.json');
 const FEED_CONFIG_DIR = path.join(ONBOARD_STATUS_DIR, 'feed_configs'); // Staging for feed configs during operation
 
+const NON_COMPLETED_ONBOARDING_STATUSES: OnboardingProcessStatus[] = [
+  OnboardingProcessStatus.PENDING,
+  OnboardingProcessStatus.VALIDATING,
+  OnboardingProcessStatus.VALIDATED,
+  OnboardingProcessStatus.PR_CREATING,
+];
+
 export class OnboardStatusManager {
   private static instance: OnboardStatusManager;
-  private activeCategoryOperations: Record<string, OnboardStatus> = {};
+  private activeCategoryOperations: Record<string, Partial<Record<OperationType, OnboardStatus>>> = {};
   private statusLock: Promise<void> = Promise.resolve();
 
   private constructor() {
@@ -67,12 +74,13 @@ export class OnboardStatusManager {
    * @param categoryName The name of the category (acting as operationId).
    * @param config The FeedConfiguration to save.
    */
-  public async saveFeedConfiguration(categoryName: string, config: FeedConfiguration): Promise<void> {
+  public async saveFeedConfiguration(categoryName: string, operationType: OperationType, config: FeedConfiguration): Promise<void> {
     await this.withLock(async () => {
       try {
         await fs.mkdir(FEED_CONFIG_DIR, { recursive: true });
         // Suffix `_feed.json` to distinguish from potential status files if names overlap
-        const configPath = path.join(FEED_CONFIG_DIR, `${categoryName}_feed.json`);
+        const operationId = this.createOperationId(categoryName, operationType);
+        const configPath = path.join(FEED_CONFIG_DIR, `${operationId}_feed.json`);
         await fs.writeFile(configPath, JSON.stringify(config, null, 2));
         Logger.debug(`Saved feed configuration for category ${categoryName} to ${configPath}`);
       } catch (error) {
@@ -87,10 +95,11 @@ export class OnboardStatusManager {
    * @param categoryName The name of the category (acting as operationId).
    * @returns A promise that resolves to the FeedConfiguration, or undefined if not found.
    */
-  public async getFeedConfiguration(categoryName: string): Promise<FeedConfiguration | undefined> {
+  public async getFeedConfiguration(categoryName: string, operationType: OperationType): Promise<FeedConfiguration | undefined> {
     return await this.withLock(async () => {
       try {
-        const configPath = path.join(FEED_CONFIG_DIR, `${categoryName}_feed.json`);
+        const operationId = this.createOperationId(categoryName, operationType);
+        const configPath = path.join(FEED_CONFIG_DIR, `${operationId}_feed.json`);
         const data = await fs.readFile(configPath, 'utf-8');
         return JSON.parse(data) as FeedConfiguration;
       } catch (error) {
@@ -106,56 +115,180 @@ export class OnboardStatusManager {
 
 
   /**
-   * Retrieves the status of a category's active operation.
-   * @param categoryName The name of the category (acting as operationId).
-   * @returns A promise that resolves to the OnboardStatus, or undefined if no active operation.
+   * Retrieves the status of a specific operation for a category.
+   * @param categoryName The name of the category.
+   * @param operationType The type of operation.
+   * @returns A promise that resolves to the OnboardStatus, or undefined if no such operation or category.
    */
-  public async getStatus(categoryName: string): Promise<OnboardStatus | undefined> {
-    await this.loadStatuses(); // Ensure latest statuses are loaded (though constructor does it initially)
-    return this.activeCategoryOperations[categoryName];
+  public async getStatus(categoryName: string, operationType: OperationType): Promise<OnboardStatus | undefined> {
+    await this.loadStatuses(); // Ensure latest statuses are loaded
+    return this.activeCategoryOperations[categoryName]?.[operationType];
   }
 
   /**
-   * Retrieves all active category operation statuses.
-   * @returns A promise that resolves to a record of all active OnboardStatus objects, keyed by categoryName.
+   * Retrieves all active category operation statuses, structured by category and then by operation type.
+   * @returns A promise that resolves to a record of all active OnboardStatus objects.
    */
-  public async getAllStatuses(): Promise<Record<string, OnboardStatus>> {
+  public async getAllStatuses(): Promise<Record<string, Partial<Record<OperationType, OnboardStatus>>>> {
     await this.loadStatuses();
     return this.activeCategoryOperations;
   }
 
   /**
-   * Updates the status of a category's active operation.
-   * If no operation exists for the category, it might create one based on the updates,
-   * or fail if `onboardingId` (categoryName) is not present in `newStatus`.
-   * For clarity, it's better if `createInitialStatus` is called first.
-   * @param categoryName The name of the category (acting as operationId).
-   * @param updates Partial OnboardStatus object with fields to update.
+   * Updates the status of a specific operation for a category.
+   * If a `stepName` is provided in `updates`, it will also add a new step.
+   * @param categoryName The name of the category.
+   * @param operationType The type of operation.
+   * @param updates Partial OnboardStatus object with fields to update. Can include `stepName` to record a new step.
+   * @param stepName Optional. If provided, a new step with this name will be recorded.
+   * @param stepStatus Optional. Status for the new step, if `stepName` is provided.
+   * @param errorMessage Optional. Error message for the new step, if `stepName` is provided.
    * @returns A promise that resolves to the updated OnboardStatus.
    */
-  public async updateStatus(categoryName: string, updates: Partial<OnboardStatus>): Promise<OnboardStatus> {
+  public async updateStatus(
+    categoryName: string,
+    operationType: OperationType,
+    updates: Partial<Omit<OnboardStatus, 'steps'>>, // Exclude steps from direct updates here
+    stepName?: string,
+    stepStatus?: OnboardingProcessStatus,
+    errorMessage?: string
+  ): Promise<OnboardStatus> {
     return await this.withLock(async () => {
-      const existingStatus = this.activeCategoryOperations[categoryName] || {
-        onboardingId: categoryName, // Ensure onboardingId is set to categoryName if creating new
-        feedName: categoryName,    // Ensure feedName is set to categoryName
-        status: OnboardingProcessStatus.PENDING, // Default status if creating new
-        lastUpdated: new Date().toISOString(),
-        operationType: updates.operationType || 'FULL_ONBOARDING', // Default operation type
-        ...updates // Apply initial updates if creating new
-      };
+      const operationId = this.createOperationId(categoryName, operationType);
+      const categoryOps = this.activeCategoryOperations[categoryName] || {};
+      let existingStatus = categoryOps[operationType];
 
-      const updatedStatus: OnboardStatus = {
+      if (!existingStatus) {
+        // If no status exists, create an initial one.
+        // This might happen if updateStatus is called before createInitialStatus,
+        // though ideally createInitialStatus should be the entry point.
+        existingStatus = {
+          onboardingId: operationId,
+          feedName: categoryName,
+          status: updates.status || OnboardingProcessStatus.PENDING,
+          lastUpdated: new Date().toISOString(),
+          operationType: operationType,
+          steps: [],
+        };
+      }
+      
+      // Apply general updates
+      let updatedStatus: OnboardStatus = {
         ...existingStatus,
         ...updates,
+        onboardingId: operationId,
+        feedName: categoryName,
+        operationType: operationType,
         lastUpdated: new Date().toISOString(),
       };
-      this.activeCategoryOperations[categoryName] = updatedStatus;
+
+      // If stepName is provided, add it as a new step
+      if (stepName) {
+        const newStep = {
+          stepName,
+          timestamp: new Date().toISOString(),
+          status: stepStatus ?? updates.status ?? existingStatus.status,
+          errorMessage: errorMessage ?? updates.errorMessage,
+        };
+        updatedStatus.steps = [...(existingStatus.steps || []), newStep];
+        
+        // If the step has a specific status, it might also update the overall status
+        if (newStep.status && newStep.status !== updatedStatus.status) {
+           updatedStatus.status = newStep.status;
+        }
+        if (newStep.errorMessage && !updatedStatus.errorMessage) {
+           updatedStatus.errorMessage = newStep.errorMessage;
+        }
+      }
+      
+      categoryOps[operationType] = updatedStatus;
+      this.activeCategoryOperations[categoryName] = categoryOps;
       await this.saveStatuses();
       return updatedStatus;
     });
   }
 
   /**
+   * A more specific method to record a step, which can also update the overall status.
+   * This is intended to replace the local `updateStatus` functions in validators/services.
+   * @param categoryName The name of the category (e.g., feed name).
+   * @param operationType The type of operation.
+   * @param stepName The description of the current step.
+   * @param serverName Optional server context for this step.
+   * @param newStatus Optional overall status to set for the operation.
+   * @param errorMessage Optional error message if this step resulted in a failure.
+   * @returns A promise that resolves to the updated OnboardStatus.
+   */
+  public async recordStep(
+    categoryName: string,
+    operationType: OperationType,
+    stepName: string,
+    serverName?: string, // Added serverName to be part of the step if relevant
+    newStatus?: OnboardingProcessStatus,
+    errorMessage?: string
+  ): Promise<OnboardStatus> {
+    return await this.withLock(async () => {
+      const operationId = this.createOperationId(categoryName, operationType);
+      const categoryOps = this.activeCategoryOperations[categoryName] || {};
+      let currentStatus = categoryOps[operationType];
+
+      if (!currentStatus) {
+        currentStatus = await this.createInitialStatus(categoryName, operationType, serverName);
+      }
+
+      const stepToAdd = {
+        stepName,
+        timestamp: new Date().toISOString(),
+        status: newStatus ?? (errorMessage ? OnboardingProcessStatus.FAILED : currentStatus.status), // Step inherits current or becomes FAILED
+        errorMessage: errorMessage,
+        ...(serverName && { serverName }), // Include serverName in the step if provided
+      };
+
+      const updatedSteps = [...(currentStatus.steps || []), stepToAdd];
+
+      const statusUpdatePayload: Partial<OnboardStatus> = {
+        steps: updatedSteps,
+        lastUpdated: new Date().toISOString(),
+      };
+
+      if (newStatus) {
+        statusUpdatePayload.status = newStatus;
+      } else if (errorMessage && currentStatus.status !== OnboardingProcessStatus.FAILED) {
+        // If an error occurs and we're not already FAILED, mark as FAILED.
+        statusUpdatePayload.status = OnboardingProcessStatus.FAILED;
+      }
+      
+      if (errorMessage && !currentStatus.errorMessage) { // Store the first error message
+        statusUpdatePayload.errorMessage = errorMessage;
+      }
+      if (serverName && !currentStatus.serverName) { // Store serverName if not already set at top level
+        statusUpdatePayload.serverName = serverName;
+      }
+
+
+      const updatedStatus: OnboardStatus = {
+        ...currentStatus,
+        ...statusUpdatePayload,
+      };
+      
+      categoryOps[operationType] = updatedStatus;
+      this.activeCategoryOperations[categoryName] = categoryOps;
+      await this.saveStatuses();
+      return updatedStatus;
+    });
+  }
+
+  /**
+   * Creates an operation ID that combines category name and operation type.
+   * @param categoryName The name of the category.
+   * @param operationType The type of operation.
+   * @returns Combined operation ID string.
+   */
+  private createOperationId(categoryName: string, operationType: OperationType): string {
+    return `${categoryName}_${operationType}`;
+  }
+
+    /**
    * Creates an initial status for a new category-wide operation.
    * The operation is identified by the categoryName.
    * @param categoryName The name of the category (also used as feedName and operationId).
@@ -165,22 +298,116 @@ export class OnboardStatusManager {
    * @returns A promise that resolves to the initial OnboardStatus.
    */
   public async createInitialStatus(categoryName: string, operationType: OperationType, serverName?: string): Promise<OnboardStatus> {
-    // The operationId is the categoryName itself for category-wide operations.
-    const operationId = categoryName;
+    // Create operation ID that includes both category and operation type
+    const operationId = this.createOperationId(categoryName, operationType);
 
     const initialStatus: OnboardStatus = {
-      onboardingId: operationId, // This is the categoryName
-      feedName: categoryName,    // Feed name is the category name
-      serverName,                // Optional server context
+      onboardingId: operationId,
+      feedName: categoryName,
+      serverName,
       status: OnboardingProcessStatus.PENDING,
-      currentStep: 'Initiated',
-      lastUpdated: new Date().toISOString(), // timestamp was an error, OnboardStatus uses lastUpdated
+      steps: [{ stepName: 'Initiated', timestamp: new Date().toISOString() }],
+      lastUpdated: new Date().toISOString(),
       operationType,
       errorMessage: undefined,
       prInfo: undefined
     };
-    // Use updateStatus to ensure it's saved correctly and lock is handled
-    return this.updateStatus(operationId, initialStatus);
+
+    // Save directly without using updateStatus, into the new structure
+    await this.withLock(async () => {
+      const categoryOps = this.activeCategoryOperations[categoryName] || {};
+      categoryOps[operationType] = initialStatus;
+      this.activeCategoryOperations[categoryName] = categoryOps;
+      await this.saveStatuses();
+    });
+
+    return initialStatus;
+  }
+
+
+  /**
+   * Finds a succeeded operation for a given feed name and operation type that has a matching feed configuration.
+   * @param feedName The name of the feed.
+   * @param operationType The type of operation.
+   * @param currentConfig The current feed configuration to compare against.
+   * @returns A promise that resolves to the OnboardStatus of the succeeded operation, or undefined if not found.
+   */
+  public async findSucceededOperation(
+    feedName: string,
+    operationType: OperationType,
+    currentConfig: FeedConfiguration
+  ): Promise<OnboardStatus | undefined> {
+    return await this.withLock(async () => {
+      for (const categoryName in this.activeCategoryOperations) {
+        const operations = this.activeCategoryOperations[categoryName];
+        if (operations) {
+          const specificOperationStatus = operations[operationType];
+          if (
+            specificOperationStatus &&
+            specificOperationStatus.feedName === feedName &&
+            specificOperationStatus.status === OnboardingProcessStatus.SUCCEEDED
+          ) {
+            // The FeedConfiguration is stored in the result of the SUCCEEDED operation
+            const savedConfig = specificOperationStatus.result?.feedConfiguration as FeedConfiguration;
+
+            if (savedConfig && this.isFeedConfigurationEqual(savedConfig, currentConfig)) {
+              return specificOperationStatus;
+            }
+          }
+        }
+      }
+      return undefined;
+    });
+  }
+
+  /**
+   * Compares two feed configurations for equality.
+   * @param config1 First feed configuration.
+   * @param config2 Second feed configuration.
+   * @returns True if the configurations are identical, false otherwise.
+   */
+  private isFeedConfigurationEqual(config1: FeedConfiguration, config2: FeedConfiguration): boolean {
+    // Compare basic properties
+    if (config1.name !== config2.name) return false;
+
+    // Compare arrays with specific order handling
+    const compareArrays = <T>(arr1: T[], arr2: T[], sortFn?: (a: T, b: T) => number): boolean => {
+      if (arr1.length !== arr2.length) return false;
+      const sorted1 = sortFn ? [...arr1].sort(sortFn) : arr1;
+      const sorted2 = sortFn ? [...arr2].sort(sortFn) : arr2;
+      return JSON.stringify(sorted1) === JSON.stringify(sorted2);
+    };
+
+    // Compare requirements array
+    if (!compareArrays(config1.requirements || [], config2.requirements || [])) return false;
+
+    // Compare MCP servers with name-based sorting
+    const sortByName = (a: McpConfig, b: McpConfig) => (a.name || '').localeCompare(b.name || '');
+    if (!compareArrays(config1.mcpServers || [], config2.mcpServers || [], sortByName)) return false;
+
+    return true;
+  }
+
+  /**
+   * 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.
+   */
+  public async _findExistingNonCompletedOperation(
+    feedName: string,
+    operationType: OperationType
+  ): Promise<OnboardStatus | undefined> {
+    const allCategoryStatuses = await this.getAllStatuses();
+    // feedName is the categoryName
+    const categoryOperations = allCategoryStatuses[feedName];
+    if (categoryOperations) {
+      const specificOperationStatus = categoryOperations[operationType];
+      if (specificOperationStatus && NON_COMPLETED_ONBOARDING_STATUSES.includes(specificOperationStatus.status)) {
+        return specificOperationStatus;
+      }
+    }
+    return undefined;
   }
 }