imcp 0.0.17 → 0.0.18

package/dist/core/onboard/OnboardProcessor.js

@@ -102,15 +102,57 @@ 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'.
      */
-    async saveFeedConfigToRepo(onboardingId, config, repoDir) {
+    async saveFeedConfigToRepo(onboardingId, config, repoDir, serverList) {
         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);
@@ -149,7 +191,7 @@ export class OnboardProcessor {
             await execAsync('git fetch upstream');
             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) {
@@ -159,7 +201,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) {
@@ -237,16 +279,18 @@ export class OnboardProcessor {
             const body = `Add new feed configuration:\n\n- Name: ${config.name}\n- Display Name: ${config.displayName}\n- Description: ${config.description}`;
             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;
             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 {
@@ -267,7 +311,7 @@ export class OnboardProcessor {
                 prUrlToReturn = prUrl.trim();
             }
             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);

package/dist/core/onboard/OnboardStatus.d.ts

@@ -16,7 +16,12 @@ export interface ServerValidationResult {
 export interface OnboardStatus {
     onboardingId: string;
     status: OnboardingProcessStatus;
-    currentStep?: string;
+    steps?: {
+        stepName: string;
+        timestamp: string;
+        status?: OnboardingProcessStatus;
+        errorMessage?: string;
+    }[];
     validationStatus?: {
         isValid: boolean;
         message?: string;

package/dist/core/onboard/OnboardStatusManager.d.ts

@@ -1,5 +1,5 @@
 import { FeedConfiguration } from '../metadatas/types.js';
-import { OnboardStatus, OperationType } from './OnboardStatus.js';
+import { OnboardStatus, OnboardingProcessStatus, OperationType } from './OnboardStatus.js';
 export declare class OnboardStatusManager {
     private static instance;
     private activeCategoryOperations;
@@ -15,43 +15,89 @@ export declare class OnboardStatusManager {
      * @param categoryName The name of the category (acting as operationId).
      * @param config The FeedConfiguration to save.
      */
-    saveFeedConfiguration(categoryName: string, config: FeedConfiguration): Promise<void>;
+    saveFeedConfiguration(categoryName: string, operationType: OperationType, config: FeedConfiguration): Promise<void>;
     /**
      * Retrieves the feed configuration associated with a category's active operation.
      * @param categoryName The name of the category (acting as operationId).
      * @returns A promise that resolves to the FeedConfiguration, or undefined if not found.
      */
-    getFeedConfiguration(categoryName: string): Promise<FeedConfiguration | undefined>;
+    getFeedConfiguration(categoryName: string, operationType: OperationType): Promise<FeedConfiguration | undefined>;
     /**
-     * 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.
      */
-    getStatus(categoryName: string): Promise<OnboardStatus | undefined>;
+    getStatus(categoryName: string, operationType: OperationType): Promise<OnboardStatus | undefined>;
     /**
-     * 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.
      */
-    getAllStatuses(): Promise<Record<string, OnboardStatus>>;
+    getAllStatuses(): Promise<Record<string, Partial<Record<OperationType, OnboardStatus>>>>;
     /**
-     * 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.
      */
-    updateStatus(categoryName: string, updates: Partial<OnboardStatus>): Promise<OnboardStatus>;
+    updateStatus(categoryName: string, operationType: OperationType, updates: Partial<Omit<OnboardStatus, 'steps'>>, // Exclude steps from direct updates here
+    stepName?: string, stepStatus?: OnboardingProcessStatus, errorMessage?: string): Promise<OnboardStatus>;
     /**
-     * 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).
-     * @param operationType The type of operation (e.g., FULL_ONBOARDING, VALIDATION_ONLY).
-     * @param serverName Optional: if the operation has a specific server context (e.g. validating a single new server in an existing category).
-     *                   However, the primary operation tracking is still by categoryName.
-     * @returns A promise that resolves to the initial OnboardStatus.
+     * 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.
      */
+    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>;
+    /**
+     * 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;
+    /**
+   * 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).
+   * @param operationType The type of operation (e.g., FULL_ONBOARDING, VALIDATION_ONLY).
+   * @param serverName Optional: if the operation has a specific server context (e.g. validating a single new server in an existing category).
+   *                   However, the primary operation tracking is still by categoryName.
+   * @returns A promise that resolves to the initial OnboardStatus.
+   */
     createInitialStatus(categoryName: string, operationType: OperationType, serverName?: string): Promise<OnboardStatus>;
+    /**
+     * 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.
+     */
+    findSucceededOperation(feedName: string, operationType: OperationType, currentConfig: FeedConfiguration): Promise<OnboardStatus | 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;
+    /**
+     * 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.
+     */
+    _findExistingNonCompletedOperation(feedName: string, operationType: OperationType): Promise<OnboardStatus | undefined>;
 }
 export declare const onboardStatusManager: OnboardStatusManager;

package/dist/core/onboard/OnboardStatusManager.js

@@ -4,8 +4,14 @@ import { SETTINGS_DIR } from '../metadatas/constants.js';
 import { OnboardingProcessStatus } 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.PENDING,
+    OnboardingProcessStatus.VALIDATING,
+    OnboardingProcessStatus.VALIDATED,
+    OnboardingProcessStatus.PR_CREATING,
+];
 export class OnboardStatusManager {
     static instance;
     activeCategoryOperations = {};
@@ -61,12 +67,13 @@ export class OnboardStatusManager {
      * @param categoryName The name of the category (acting as operationId).
      * @param config The FeedConfiguration to save.
      */
-    async saveFeedConfiguration(categoryName, config) {
+    async saveFeedConfiguration(categoryName, operationType, config) {
         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}`);
             }
@@ -81,10 +88,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.
      */
-    async getFeedConfiguration(categoryName) {
+    async getFeedConfiguration(categoryName, operationType) {
         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);
             }
@@ -99,76 +107,252 @@ 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.
      */
-    async getStatus(categoryName) {
-        await this.loadStatuses(); // Ensure latest statuses are loaded (though constructor does it initially)
-        return this.activeCategoryOperations[categoryName];
+    async getStatus(categoryName, operationType) {
+        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.
      */
     async getAllStatuses() {
         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.
      */
-    async updateStatus(categoryName, updates) {
+    async updateStatus(categoryName, operationType, updates, // Exclude steps from direct updates here
+    stepName, stepStatus, errorMessage) {
         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 updatedStatus = {
+            const operationId = this.createOperationId(categoryName, operationType);
+            const categoryOps = this.activeCategoryOperations[categoryName] || {};
+            let existingStatus = categoryOps[operationType];
+            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 = {
                 ...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;
         });
     }
     /**
-     * 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).
-     * @param operationType The type of operation (e.g., FULL_ONBOARDING, VALIDATION_ONLY).
-     * @param serverName Optional: if the operation has a specific server context (e.g. validating a single new server in an existing category).
-     *                   However, the primary operation tracking is still by categoryName.
-     * @returns A promise that resolves to the initial OnboardStatus.
+     * 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.
      */
+    async recordStep(categoryName, operationType, stepName, serverName, // Added serverName to be part of the step if relevant
+    newStatus, errorMessage) {
+        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 = {
+                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 = {
+                ...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.
+     */
+    createOperationId(categoryName, operationType) {
+        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).
+   * @param operationType The type of operation (e.g., FULL_ONBOARDING, VALIDATION_ONLY).
+   * @param serverName Optional: if the operation has a specific server context (e.g. validating a single new server in an existing category).
+   *                   However, the primary operation tracking is still by categoryName.
+   * @returns A promise that resolves to the initial OnboardStatus.
+   */
     async createInitialStatus(categoryName, operationType, serverName) {
-        // 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 = {
-            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.
+     */
+    async findSucceededOperation(feedName, operationType, currentConfig) {
+        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;
+                        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.
+     */
+    isFeedConfigurationEqual(config1, config2) {
+        // Compare basic properties
+        if (config1.name !== config2.name)
+            return false;
+        // Compare arrays with specific order handling
+        const compareArrays = (arr1, arr2, sortFn) => {
+            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, b) => (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.
+     */
+    async _findExistingNonCompletedOperation(feedName, operationType) {
+        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;
     }
 }
 // Export singleton instance

package/dist/core/validators/FeedValidator.d.ts

@@ -1,4 +1,5 @@
 import { FeedConfiguration, McpConfig } from "../metadatas/types.js";
+import { OperationType } from "../onboard/OnboardStatus.js";
 /**
  * Validates feed configurations to ensure they meet required criteria
  */
@@ -6,15 +7,19 @@ export declare class FeedValidator {
     /**
      * Validates a feed configuration
      * @param config The feed configuration to validate
+     * @param categoryName The name of the category (feed name) for status updates
+     * @param operationType The type of operation for status updates
      * @returns true if valid, throws error if invalid
      */
-    validate(config: FeedConfiguration): boolean;
+    validate(config: FeedConfiguration, categoryName: string, operationType: OperationType): Promise<boolean>;
     /**
      * Validates a single MCP server configuration using the appropriate validator
      * @param server The MCP server configuration to validate
      * @param config The feed configuration containing shared requirements
+     * @param categoryName The name of the category (feed name) for status updates
+     * @param operationType The type of operation for status updates
      * @returns true if valid, throws error if invalid
      */
-    validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean>;
+    validateServer(server: McpConfig, config: FeedConfiguration, categoryName: string, operationType: OperationType): Promise<boolean>;
 }
 export declare const feedValidator: FeedValidator;