imcp 0.0.14 → 0.0.16

package/dist/core/onboard/OnboardProcessor.js

@@ -0,0 +1,290 @@
+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 { Logger } from '../../utils/logger.js';
+const execAsync = promisify(exec);
+/**
+ * Class responsible for handling GitHub operations during the onboarding process
+ */
+export class OnboardProcessor {
+    /**
+     * Forks the GitHub repository specified in GITHUB_REPO constants.
+     * Uses the `gh repo fork` command.
+     * @param onboardingId The ID of the onboarding process (for logging).
+     * @param repoDir The directory of the repository (currently unused but kept for consistency).
+     * @throws An error if the forking process fails, with a 'step' property set to 'forkRepo'.
+     */
+    async forkRepo(onboardingId, repoDir) {
+        try {
+            // Using --remote=true ensures that if the fork already exists, 'origin' remote is set to it.
+            // If the fork doesn't exist, it creates it and sets 'origin' remote.
+            await execAsync(`gh repo fork ${GITHUB_REPO.repoName} --clone=false --remote=true`);
+            Logger.debug(`[${onboardingId}] Successfully ensured repository is forked and remote 'origin' is set.`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            Logger.error(`[${onboardingId}] Error during forkRepo: ${errorMessage}`);
+            throw Object.assign(new Error(`Failed to fork repository: ${errorMessage}`), { step: 'forkRepo' });
+        }
+    }
+    /**
+     * Clones the user's fork of the repository into a temporary directory.
+     * It first removes any existing repository directory for the current onboarding process.
+     * Then, it retrieves the GitHub username and constructs the repository URL to clone.
+     * @param onboardingId The ID of the onboarding process (for logging).
+     * @param tempDir The base temporary directory for the onboarding process.
+     * @param repoDir The specific directory within tempDir where the repository will be cloned.
+     * @throws An error if cloning fails, with a 'step' property set to 'cloneRepo'.
+     */
+    async cloneRepo(onboardingId, tempDir, repoDir) {
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            let repoExistsAndIsValid = false;
+            const originalCwd = process.cwd();
+            try {
+                const gitDirStat = await fs.stat(path.join(repoDir, '.git'));
+                if (gitDirStat.isDirectory()) {
+                    process.chdir(repoDir);
+                    const { stdout: remoteUrlStdout } = await execAsync(`git config --get remote.origin.url`);
+                    const remoteUrl = remoteUrlStdout.trim();
+                    process.chdir(originalCwd);
+                    const username = await this.getGitHubUsername();
+                    const expectedRepoName = GITHUB_REPO.repoName.split('/')[1];
+                    if (remoteUrl.includes(username) && remoteUrl.includes(expectedRepoName)) {
+                        Logger.debug(`[${onboardingId}] Repository directory ${repoDir} already exists, is a valid git repository, and has the correct remote origin. Skipping clone.`);
+                        repoExistsAndIsValid = true;
+                    }
+                    else {
+                        Logger.log(`WARNING: [${onboardingId}] Repository directory ${repoDir} exists and is a git repository, but remote 'origin' URL (${remoteUrl}) does not match expected user/repo. Will re-clone.`);
+                    }
+                }
+            }
+            catch (checkError) {
+                Logger.debug(`[${onboardingId}] Repository directory ${repoDir} check failed or is not the correct repository. Proceeding with clone. Error: ${checkError.message || checkError.code}`);
+                if (process.cwd() !== originalCwd) {
+                    process.chdir(originalCwd);
+                }
+            }
+            if (!repoExistsAndIsValid) {
+                await fs.rm(repoDir, { recursive: true, force: true });
+                Logger.debug(`[${onboardingId}] Cleaned up existing directory (if any) at ${repoDir}.`);
+                const username = await this.getGitHubUsername();
+                const repoUrl = `https://github.com/${username}/${GITHUB_REPO.repoName.split('/')[1]}.git`;
+                await execAsync(`git clone ${repoUrl} ${repoDir}`);
+                Logger.debug(`[${onboardingId}] Successfully cloned repository to ${repoDir}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            Logger.error(`[${onboardingId}] Error during cloneRepo: ${errorMessage}`);
+            throw Object.assign(new Error(`Failed to clone repository: ${errorMessage}`), { step: 'cloneRepo' });
+        }
+    }
+    /**
+     * Retrieves the GitHub username of the authenticated user using the `gh api user` command.
+     * @returns A promise that resolves to the GitHub username as a string.
+     * @throws An error if fetching the username fails.
+     */
+    async getGitHubUsername() {
+        try {
+            const { stdout } = await execAsync('gh api user -q .login');
+            return stdout.trim();
+        }
+        catch (error) {
+            throw new Error(`Failed to get GitHub username: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Saves the feed configuration as a JSON file into the specified path within the cloned repository.
+     * The file will be named `config.name.json`.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration to save.
+     * @param repoDir The root directory of the cloned repository.
+     * @throws An error if saving the configuration fails, with a 'step' property set to 'saveFeedConfigToRepo'.
+     */
+    async saveFeedConfigToRepo(onboardingId, config, repoDir) {
+        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}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            Logger.error(`[${onboardingId}] Error during saveFeedConfigToRepo: ${errorMessage}`);
+            throw Object.assign(new Error(`Failed to save feed configuration to repo: ${errorMessage}`), { step: 'saveFeedConfigToRepo' });
+        }
+    }
+    /**
+     * Creates a pull request on GitHub for the newly added feed configuration.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration, used for branch name and PR details.
+     * @param repoDir The root directory of the cloned repository.
+     * @returns A promise that resolves to an object containing the URL of the created PR and the branch name.
+     * @throws An error if any step of the PR creation process fails.
+     */
+    /**
+     * Sets up a clean branch for the feed configuration changes.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     * @param repoDir The root directory of the cloned repository.
+     * @returns The name of the created branch.
+     * @throws An error if branch setup fails.
+     */
+    async setupBranch(onboardingId, config, repoDir) {
+        try {
+            process.chdir(repoDir);
+            try {
+                await execAsync(`git remote get-url upstream`);
+                await execAsync(`git remote set-url upstream ${GITHUB_REPO.url}`);
+                Logger.debug(`[${onboardingId}] Updated 'upstream' remote URL to ${GITHUB_REPO.url}`);
+            }
+            catch (remoteError) {
+                await execAsync(`git remote add upstream ${GITHUB_REPO.url}`);
+                Logger.debug(`[${onboardingId}] Added 'upstream' remote with URL ${GITHUB_REPO.url}`);
+            }
+            await execAsync('git fetch upstream');
+            Logger.debug(`[${onboardingId}] Fetched from upstream.`);
+            try {
+                await execAsync('git checkout main');
+                Logger.debug(`[${onboardingId}] Switched to existing local branch 'main'.`);
+            }
+            catch (checkoutMainError) {
+                const errStdErr = checkoutMainError.stderr || '';
+                if (errStdErr.includes('did not match any file(s) known to git') ||
+                    errStdErr.includes('is not a commit and a branch') ||
+                    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');
+                        Logger.debug(`[${onboardingId}] Created and switched to local branch 'main' from 'upstream/main'.`);
+                    }
+                    catch (createMainError) {
+                        const errMsg = createMainError instanceof Error ? createMainError.message : String(createMainError);
+                        Logger.error(`[${onboardingId}] Failed to create local branch 'main' from 'upstream/main': ${errMsg}. Stderr: ${createMainError.stderr}`);
+                        throw Object.assign(new Error(`Failed to create local branch 'main': ${errMsg}`), { step: 'setupBranch.setupMainBranch' });
+                    }
+                }
+                else {
+                    const errMsg = checkoutMainError instanceof Error ? checkoutMainError.message : String(checkoutMainError);
+                    Logger.error(`[${onboardingId}] Failed to checkout local branch 'main': ${errMsg}. Stderr: ${checkoutMainError.stderr}`);
+                    throw Object.assign(new Error(`Failed to checkout local branch 'main': ${errMsg}`), { step: 'setupBranch.checkoutMainBranch' });
+                }
+            }
+            await execAsync('git reset --hard upstream/main');
+            Logger.debug(`[${onboardingId}] Local 'main' branch is now hard reset to 'upstream/main'.`);
+            const branchName = `feed/${config.name}`;
+            try {
+                await execAsync(`git branch -D ${branchName}`);
+                Logger.debug(`[${onboardingId}] Deleted local branch '${branchName}' as it may have existed.`);
+            }
+            catch (deleteError) {
+                const errStdErrDelete = deleteError.stderr || '';
+                if (errStdErrDelete.includes('not found') || errStdErrDelete.includes('not found.')) {
+                    Logger.debug(`[${onboardingId}] Local branch '${branchName}' did not exist, no need to delete.`);
+                }
+                else {
+                    const errorMessage = deleteError instanceof Error ? deleteError.message : String(deleteError);
+                    Logger.error(`[${onboardingId}] Failed to delete local branch '${branchName}': ${errorMessage}. Stderr: ${deleteError.stderr}`);
+                    throw Object.assign(new Error(`Failed to delete local branch '${branchName}': ${errorMessage}`), { step: 'setupBranch.deleteFeatureBranch' });
+                }
+            }
+            await execAsync(`git checkout -b ${branchName} upstream/main`);
+            Logger.debug(`[${onboardingId}] Created and checked out new branch '${branchName}' from 'upstream/main'.`);
+            return branchName;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            Logger.error(`[${onboardingId}] Error during branch setup: ${errorMessage}`);
+            throw Object.assign(new Error(`Failed to setup branch: ${errorMessage}`), { step: 'setupBranch' });
+        }
+    }
+    /**
+     * Creates a pull request for the feed configuration changes.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     * @param repoDir The root directory of the cloned repository.
+     * @param branchName The name of the branch to create the PR from.
+     * @returns Object containing the PR URL and branch name.
+     * @throws An error if PR creation fails.
+     */
+    async createPullRequest(onboardingId, config, repoDir, branchName) {
+        try {
+            process.chdir(repoDir);
+            // Stage and commit changes
+            await execAsync('git add .');
+            await execAsync(`git commit --allow-empty -m "Add feed configuration for ${config.name}"`);
+            Logger.debug(`[${onboardingId}] Committed changes (or allowed empty commit) for ${config.name}.`);
+            // Push to origin
+            await execAsync(`git push -u -f origin ${branchName}`);
+            Logger.debug(`[${onboardingId}] Pushed branch ${branchName} to origin. Verifying remote branch...`);
+            try {
+                const { stdout: remoteBranchCheck } = await execAsync(`git ls-remote origin refs/heads/${branchName}`);
+                if (!remoteBranchCheck.includes(`refs/heads/${branchName}`)) {
+                    throw new Error(`Branch ${branchName} not found on remote 'origin' (fork) after push. Output of ls-remote: ${remoteBranchCheck}`);
+                }
+                Logger.debug(`[${onboardingId}] Branch ${branchName} confirmed on remote 'origin' (fork).`);
+            }
+            catch (verifyError) {
+                const errorMessage = verifyError instanceof Error ? verifyError.message : String(verifyError);
+                Logger.error(`[${onboardingId}] Failed to verify branch ${branchName} on remote 'origin' (fork) after push: ${errorMessage}`);
+                throw new Error(`Verification of branch ${branchName} on remote 'origin' (fork) failed: ${errorMessage}`);
+            }
+            const title = `Add feed configuration for ${config.name}`;
+            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`;
+            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}"`;
+            if (existingPrJson && existingPrJson.trim() !== '[]' && existingPrJson.trim() !== '') {
+                try {
+                    const prs = JSON.parse(existingPrJson);
+                    if (prs.length > 0 && prs[0].url) {
+                        prUrlToReturn = prs[0].url;
+                        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.`);
+                        const { stdout: prUrl } = await execAsync(createPRCommand);
+                        prUrlToReturn = prUrl.trim();
+                    }
+                }
+                catch (parseError) {
+                    Logger.log(`WARNING: [${onboardingId}] Could not parse existing PR JSON: ${existingPrJson}. Proceeding to create new PR. Error: ${parseError}`);
+                    const { stdout: prUrl } = await execAsync(createPRCommand);
+                    prUrlToReturn = prUrl.trim();
+                }
+            }
+            else {
+                Logger.debug(`[${onboardingId}] No existing PR found. Proceeding to create PR.`);
+                const { stdout: prUrl } = await execAsync(createPRCommand);
+                prUrlToReturn = prUrl.trim();
+            }
+            Logger.debug(`[${onboardingId}] Pull request operation completed. PR URL: ${prUrlToReturn}`);
+            return { url: prUrlToReturn, branchName };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            Logger.error(`[${onboardingId}] Error during createPullRequest: ${errorMessage}`);
+            throw Object.assign(new Error(`Failed to create pull request: ${errorMessage}`), { step: 'createPullRequest' });
+        }
+    }
+    /**
+     * Creates necessary directories for the onboarding process
+     * @param onboardingId The ID of the onboarding process
+     * @returns Object containing tempDir and repoDir paths
+     */
+    createDirectories(onboardingId) {
+        const tempDir = path.join(SETTINGS_DIR, 'onboard', 'temp', onboardingId);
+        const repoDir = path.join(tempDir, 'imcp-feed');
+        return { tempDir, repoDir };
+    }
+}
+export const onboardProcessor = new OnboardProcessor();
+//# sourceMappingURL=OnboardProcessor.js.map

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

@@ -0,0 +1,49 @@
+import { FeedConfiguration } from "../types.js";
+export declare enum OnboardingProcessStatus {
+    VALIDATING = "validating",
+    VALIDATED = "validated",
+    PR_CREATING = "prcreating",
+    FAILED = "failed",
+    SUCCEEDED = "succeeded",
+    PENDING = "pending"
+}
+export type OperationType = 'FULL_ONBOARDING' | 'VALIDATION_ONLY';
+export interface ServerValidationResult {
+    serverName: string;
+    isValid: boolean;
+    message?: string;
+}
+export interface OnboardStatus {
+    onboardingId: string;
+    status: OnboardingProcessStatus;
+    currentStep?: string;
+    validationStatus?: {
+        isValid: boolean;
+        message?: string;
+        serverResults?: ServerValidationResult[];
+    };
+    prInfo?: {
+        url?: string;
+        branchName?: string;
+    };
+    result?: any;
+    errorMessage?: string;
+    lastUpdated: string;
+    feedName: string;
+    serverName?: string;
+    operationType?: OperationType;
+}
+export interface OperationStatus {
+    onboardingId: string;
+    status: OnboardingProcessStatus;
+    message?: string;
+    lastQueried?: string;
+}
+export interface ValidationOperationResult {
+    validationStatus: {
+        isValid: boolean;
+        message?: string;
+        serverResults?: ServerValidationResult[];
+    };
+    feedConfiguration?: FeedConfiguration;
+}

package/dist/core/onboard/OnboardStatus.js

@@ -0,0 +1,10 @@
+export var OnboardingProcessStatus;
+(function (OnboardingProcessStatus) {
+    OnboardingProcessStatus["VALIDATING"] = "validating";
+    OnboardingProcessStatus["VALIDATED"] = "validated";
+    OnboardingProcessStatus["PR_CREATING"] = "prcreating";
+    OnboardingProcessStatus["FAILED"] = "failed";
+    OnboardingProcessStatus["SUCCEEDED"] = "succeeded";
+    OnboardingProcessStatus["PENDING"] = "pending";
+})(OnboardingProcessStatus || (OnboardingProcessStatus = {}));
+//# sourceMappingURL=OnboardStatus.js.map

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

@@ -0,0 +1,57 @@
+import { FeedConfiguration } from '../types.js';
+import { OnboardStatus, OperationType } from './OnboardStatus.js';
+export declare class OnboardStatusManager {
+    private static instance;
+    private activeCategoryOperations;
+    private statusLock;
+    private constructor();
+    static getInstance(): OnboardStatusManager;
+    private withLock;
+    private loadStatuses;
+    private saveStatuses;
+    /**
+     * Saves the feed configuration associated with a category's active operation.
+     * The operation is identified by the categoryName.
+     * @param categoryName The name of the category (acting as operationId).
+     * @param config The FeedConfiguration to save.
+     */
+    saveFeedConfiguration(categoryName: string, 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>;
+    /**
+     * 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.
+     */
+    getStatus(categoryName: string): 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.
+     */
+    getAllStatuses(): Promise<Record<string, 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.
+     * @returns A promise that resolves to the updated OnboardStatus.
+     */
+    updateStatus(categoryName: string, updates: Partial<OnboardStatus>): 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.
+     */
+    createInitialStatus(categoryName: string, operationType: OperationType, serverName?: string): Promise<OnboardStatus>;
+}
+export declare const onboardStatusManager: OnboardStatusManager;

package/dist/core/onboard/OnboardStatusManager.js

@@ -0,0 +1,176 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SETTINGS_DIR } from '../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 FEED_CONFIG_DIR = path.join(ONBOARD_STATUS_DIR, 'feed_configs'); // Staging for feed configs during operation
+export class OnboardStatusManager {
+    static instance;
+    activeCategoryOperations = {};
+    statusLock = Promise.resolve();
+    constructor() {
+        this.loadStatuses().catch(error => Logger.error('Failed to initialize OnboardStatusManager:', error));
+    }
+    static getInstance() {
+        if (!OnboardStatusManager.instance) {
+            OnboardStatusManager.instance = new OnboardStatusManager();
+        }
+        return OnboardStatusManager.instance;
+    }
+    async withLock(operation) {
+        const current = this.statusLock;
+        let resolve;
+        this.statusLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async loadStatuses() {
+        await this.withLock(async () => {
+            try {
+                await fs.mkdir(ONBOARD_STATUS_DIR, { recursive: true });
+                await fs.mkdir(FEED_CONFIG_DIR, { recursive: true });
+                const data = await fs.readFile(CATEGORY_OPERATIONS_STATUS_FILE, 'utf-8');
+                this.activeCategoryOperations = JSON.parse(data);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    this.activeCategoryOperations = {};
+                    await this.saveStatuses(); // Create the file if it doesn't exist
+                }
+                else {
+                    Logger.error('Failed to load onboarding statuses:', error);
+                    this.activeCategoryOperations = {}; // Initialize with empty statuses in case of other errors
+                }
+            }
+        });
+    }
+    async saveStatuses() {
+        await fs.mkdir(ONBOARD_STATUS_DIR, { recursive: true });
+        await fs.writeFile(CATEGORY_OPERATIONS_STATUS_FILE, JSON.stringify(this.activeCategoryOperations, null, 2));
+    }
+    /**
+     * Saves the feed configuration associated with a category's active operation.
+     * The operation is identified by the categoryName.
+     * @param categoryName The name of the category (acting as operationId).
+     * @param config The FeedConfiguration to save.
+     */
+    async saveFeedConfiguration(categoryName, 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`);
+                await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+                Logger.debug(`Saved feed configuration for category ${categoryName} to ${configPath}`);
+            }
+            catch (error) {
+                Logger.error(`Failed to save feed configuration for category ${categoryName}:`, error);
+                throw error; // Re-throw to allow caller to handle
+            }
+        });
+    }
+    /**
+     * 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.
+     */
+    async getFeedConfiguration(categoryName) {
+        return await this.withLock(async () => {
+            try {
+                const configPath = path.join(FEED_CONFIG_DIR, `${categoryName}_feed.json`);
+                const data = await fs.readFile(configPath, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    return undefined; // File not found, not an error state for this getter
+                }
+                // Log other errors but still return undefined as the config couldn't be retrieved.
+                Logger.error(`Failed to read feed configuration for category ${categoryName}:`, error);
+                return undefined; // Ensure undefined is returned on other errors too
+            }
+        });
+    }
+    /**
+     * 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.
+     */
+    async getStatus(categoryName) {
+        await this.loadStatuses(); // Ensure latest statuses are loaded (though constructor does it initially)
+        return this.activeCategoryOperations[categoryName];
+    }
+    /**
+     * Retrieves all active category operation statuses.
+     * @returns A promise that resolves to a record of all active OnboardStatus objects, keyed by categoryName.
+     */
+    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.
+     * @returns A promise that resolves to the updated OnboardStatus.
+     */
+    async updateStatus(categoryName, updates) {
+        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 = {
+                ...existingStatus,
+                ...updates,
+                lastUpdated: new Date().toISOString(),
+            };
+            this.activeCategoryOperations[categoryName] = updatedStatus;
+            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.
+     */
+    async createInitialStatus(categoryName, operationType, serverName) {
+        // The operationId is the categoryName itself for category-wide operations.
+        const operationId = categoryName;
+        const initialStatus = {
+            onboardingId: operationId, // This is the categoryName
+            feedName: categoryName, // Feed name is the category name
+            serverName, // Optional server context
+            status: OnboardingProcessStatus.PENDING,
+            currentStep: 'Initiated',
+            lastUpdated: new Date().toISOString(), // timestamp was an error, OnboardStatus uses lastUpdated
+            operationType,
+            errorMessage: undefined,
+            prInfo: undefined
+        };
+        // Use updateStatus to ensure it's saved correctly and lock is handled
+        return this.updateStatus(operationId, initialStatus);
+    }
+}
+// Export singleton instance
+export const onboardStatusManager = OnboardStatusManager.getInstance();
+//# sourceMappingURL=OnboardStatusManager.js.map

package/dist/core/types.d.ts

@@ -17,10 +17,12 @@ export interface RequirementStatus {
     lastCheckTime?: string;
     operationStatus?: OperationStatus;
     pythonEnv?: string;
+    npmPath?: string;
 }
 export interface MCPServerStatus {
     installedStatus: Record<string, OperationStatus>;
     name: string;
+    tags?: string[];
     error?: string;
 }
 export interface OperationStatus {
@@ -41,6 +43,7 @@ export interface MCPServerCategory {
     displayName: string;
     description?: string;
     type: 'local';
+    tags?: string[];
     path?: string;
     installationStatus?: InstallationStatus;
     feedConfiguration?: FeedConfiguration;
@@ -114,11 +117,7 @@ export interface RegistryConfig {
     };
     artifacts?: {
         registryUrl: string;
-        assetName?: string;
-    };
-    local?: {
-        localPath: string;
-        assetName?: string;
+        registryName: string;
     };
 }
 export interface RequirementConfig {

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

@@ -1,4 +1,4 @@
-import { FeedConfiguration } from "../types.js";
+import { FeedConfiguration, McpConfig } from "../types.js";
 /**
  * Validates feed configurations to ensure they meet required criteria
  */
@@ -9,5 +9,12 @@ export declare class FeedValidator {
      * @returns true if valid, throws error if invalid
      */
     validate(config: FeedConfiguration): 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
+     * @returns true if valid, throws error if invalid
+     */
+    validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean>;
 }
 export declare const feedValidator: FeedValidator;