imcp 0.0.13 → 0.0.15

package/dist/core/installers/requirements/PipInstaller.js

@@ -1,5 +1,9 @@
 import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
+// Assuming getArtifactLatestVersion will be available in adoUtils.ts
+import { handleArtifact as handleAdoArtifact, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { Logger } from '../../../utils/logger.js';
 /**
  * Installer implementation for Python packages using pip
  */
@@ -20,29 +24,71 @@ export class PipInstaller extends BaseInstaller {
         return requirement.type === 'pip';
     }
     supportCheckUpdates() {
-        /// temporarily disabling update check for pip as not able to get which pip of python is being used
         return true;
     }
+    /**
+     * Get the latest version available for the pip package.
+     * @param requirement The requirement to check.
+     * @param options Optional server install options.
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    async getLatestVersion(requirement, options) {
+        if (requirement.registry) {
+            if (requirement.registry.githubRelease) {
+                return getGitHubLatestVersion(this.execPromise, requirement.registry.githubRelease.repository);
+            }
+            else if (requirement.registry.artifacts) {
+                // Assuming getArtifactLatestVersion exists and has a compatible signature
+                return getArtifactLatestVersion(requirement, requirement.registry.artifacts, options);
+            }
+        }
+        // Default: get common latest version from pip index
+        const pipCmd = this.getPipCommand(options);
+        const { stdout } = await this.execPromise(`${pipCmd} index versions ${requirement.name} --pre=0`);
+        // Parse output to find the latest version. Example output:
+        // mypackage (1.0.0)
+        // Available versions: 1.0.0, 0.9.0
+        // LATEST:          1.0.0
+        // Or for some packages:
+        // mypackage
+        // VERSIONS: 1.0.0, 0.9.0
+        // Latest: 1.0.0
+        const latestMatch = stdout.match(/(?:LATEST|Latest):\s*([^\s]+)/);
+        if (latestMatch && latestMatch[1]) {
+            return latestMatch[1];
+        }
+        // Fallback if LATEST line is not found, try to get the first version from "Available versions" or "VERSIONS"
+        const versionsMatch = stdout.match(/(?:Available versions|VERSIONS):\s*([^\n]+)/);
+        if (versionsMatch && versionsMatch[1]) {
+            const versions = versionsMatch[1].split(',').map(v => v.trim());
+            if (versions.length > 0) {
+                // Assuming versions are listed in a somewhat reasonable order,
+                // or we might need more sophisticated version sorting here.
+                return versions[0];
+            }
+        }
+        return undefined; // Or throw an error if version cannot be determined
+    }
     /**
      * Check if the Python package is already installed
      * @param requirement The requirement to check
+     * @param options Optional server install options
      * @returns The status of the requirement
      */
     async checkInstallation(requirement, options) {
         try {
             const pipCmd = this.getPipCommand(options);
             const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
-            // If we get an output and no error, the package is installed
-            const installed = stdout.includes(requirement.name);
+            const installed = stdout.includes(requirement.name.toLowerCase());
             const versionMatch = stdout.match(/Version: (.+)/);
             const installedVersion = versionMatch ? versionMatch[1] : undefined;
             return {
                 name: requirement.name,
                 type: 'pip',
-                installed,
+                installed: installed,
                 version: installedVersion,
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv in status check too
+                pythonEnv: this.getPythonCommand(options)
             };
         }
         catch (error) {
@@ -52,70 +98,62 @@ export class PipInstaller extends BaseInstaller {
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv even in error case
+                pythonEnv: this.getPythonCommand(options)
             };
         }
     }
     /**
      * Install the Python package
      * @param requirement The requirement to install
+     * @param options Optional server install options
      * @returns The status of the installation
      */
     async install(requirement, options) {
         try {
             const status = await this.checkInstallation(requirement, options);
-            if (status.installed) {
+            if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0 && !requirement.version.toLowerCase().includes('latest')) {
+                Logger.log(`${requirement.name}==${status.version} already installed for ${this.getPythonCommand}.`);
                 return status;
             }
             const pipCmd = this.getPipCommand(options);
-            // If no registry is specified, use standard pip installation
             if (!requirement.registry) {
-                // Standard pip installation
                 const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
                 if (stderr && stderr.toLowerCase().includes('error')) {
                     throw new Error(stderr);
                 }
             }
             else {
-                // Handle different registry types
                 let packageSource;
                 if (requirement.registry.githubRelease) {
                     const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
                     packageSource = result.resolvedPath;
-                    // Install from the downloaded wheel or tar.gz file
                     const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }
                 }
                 else if (requirement.registry.artifacts) {
-                    const registryUrl = requirement.registry.artifacts.registryUrl;
-                    // Install using the custom index URL
-                    const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`);
+                    const pythonCmd = this.getPythonCommand(options);
+                    const adoArtifactResult = await handleAdoArtifact(requirement, requirement.registry.artifacts, pythonCmd);
+                    const { stderr } = await this.execPromise(`${pipCmd} install ${adoArtifactResult.package} --extra-index-url ${adoArtifactResult.registryUrl}`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
-                    }
-                }
-                else if (requirement.registry.local) {
-                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
-                    // Install from the local path
-                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
+                        const checkStatus = await this.checkInstallation(requirement, options);
+                        if (!checkStatus.installed) {
+                            throw new Error(`Pip installation failed with: ${stderr}`);
+                        }
                     }
                 }
                 else {
                     throw new Error('Invalid registry configuration');
                 }
             }
-            // Store the pythonEnv in the status for future use
             return {
                 name: requirement.name,
                 type: 'pip',
                 installed: true,
-                version: requirement.version,
+                version: requirement.version, // This might need to be updated to actual installed version
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Store the python env
+                pythonEnv: this.getPythonCommand(options)
             };
         }
         catch (error) {
@@ -125,7 +163,7 @@ export class PipInstaller extends BaseInstaller {
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Store the python env
+                pythonEnv: this.getPythonCommand(options)
             };
         }
     }

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

@@ -0,0 +1,72 @@
+import { FeedConfiguration } from '../types.js';
+import { OperationStatus } from './OnboardStatus.js';
+/**
+ * Service for handling feed onboarding operations
+ */
+export declare class FeedOnboardService {
+    constructor();
+    /**
+     * Onboard a new feed configuration
+     * @param config Feed configuration to onboard
+     */
+    onboardFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
+        feedConfiguration?: FeedConfiguration;
+    }>;
+    /**
+     * Validate a feed configuration without performing full onboarding
+     * @param config Feed configuration to validate
+     * @returns Operation status indicating the result of the validation initiation
+     */
+    validateFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
+        feedConfiguration?: FeedConfiguration;
+    }>;
+    /**
+     * Initiates either a full onboarding or a validation-only operation.
+     * It checks for existing non-completed operations for the same feed and operation type.
+     * If an existing operation is found, its status is returned. Otherwise, a new operation is created and started.
+     * @param config The feed configuration.
+     * @param operationType The type of operation to initiate (FULL_ONBOARDING or VALIDATION_ONLY).
+     * @returns A promise that resolves to the operation status.
+     */
+    private _initiateOperation;
+    /**
+     * Finds an existing non-completed operation for a given feed name, server name, and operation type.
+     * @param feedName The name of the feed.
+     * @param operationType The type of operation.
+     * @returns A promise that resolves to the OnboardStatus of the existing operation, or undefined if not found.
+     */
+    private _findExistingNonCompletedOperation;
+    /**
+     * Performs static validation of the feed configuration.
+     * @param config The feed configuration to validate.
+     * @param forExistingCategory Whether this is for an existing category.
+     * @throws Error if validation fails.
+     */
+    private validateStaticConfig;
+    /**
+     * Validates the feed configuration.
+     * Updates the onboarding status to VALIDATING, then to VALIDATED or FAILED based on the validation result.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration to validate.
+     * @throws Error if validation fails, to be caught by the calling process.
+     */
+    private _validateFeedConfiguration;
+    /**
+     * Processes a validation-only operation for a feed configuration.
+     * It validates the configuration and updates the status to SUCCEEDED if validation is successful.
+     * If validation fails, the error is handled by _validateFeedConfiguration and the calling _initiateOperation method.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     */
+    private processValidationOnly;
+    /**
+     * Processes the full onboarding for a feed configuration.
+     * This includes validation, forking/cloning the repository, saving the config, and creating a pull request.
+     * Manages status updates throughout the process and handles cleanup of temporary directories.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     * @throws Error if any step of the full onboarding process fails.
+     */
+    private processFullOnboarding;
+}
+export declare const feedOnboardService: FeedOnboardService;

package/dist/core/onboard/FeedOnboardService.js

@@ -0,0 +1,312 @@
+import { configProvider } from '../ConfigurationProvider.js';
+import { feedValidator } from '../validators/FeedValidator.js';
+import { Logger } from '../../utils/logger.js';
+import { OnboardingProcessStatus } from './OnboardStatus.js';
+import { onboardStatusManager } from './OnboardStatusManager.js';
+import { onboardProcessor } from './OnboardProcessor.js';
+const NON_COMPLETED_ONBOARDING_STATUSES = [
+    OnboardingProcessStatus.PENDING,
+    OnboardingProcessStatus.VALIDATING,
+    OnboardingProcessStatus.VALIDATED,
+    OnboardingProcessStatus.PR_CREATING,
+];
+/**
+ * Service for handling feed onboarding operations
+ */
+export class FeedOnboardService {
+    // tempDir and repoDir will be generated per onboarding process
+    constructor() {
+        // No shared tempDir or repoDir at instance level
+    }
+    /**
+     * Onboard a new feed configuration
+     * @param config Feed configuration to onboard
+     */
+    async onboardFeed(config, forExistingCategory) {
+        // Perform static validation first
+        await this.validateStaticConfig(config, forExistingCategory);
+        const operationStatus = await this._initiateOperation(config, 'FULL_ONBOARDING', forExistingCategory);
+        return { ...operationStatus, feedConfiguration: config };
+    }
+    /**
+     * Validate a feed configuration without performing full onboarding
+     * @param config Feed configuration to validate
+     * @returns Operation status indicating the result of the validation initiation
+     */
+    async validateFeed(config, forExistingCategory) {
+        // Perform static validation first
+        await this.validateStaticConfig(config, forExistingCategory);
+        const operationStatus = await this._initiateOperation(config, 'VALIDATION_ONLY', forExistingCategory);
+        return { ...operationStatus, feedConfiguration: config };
+    }
+    /**
+     * Initiates either a full onboarding or a validation-only operation.
+     * It checks for existing non-completed operations for the same feed and operation type.
+     * If an existing operation is found, its status is returned. Otherwise, a new operation is created and started.
+     * @param config The feed configuration.
+     * @param operationType The type of operation to initiate (FULL_ONBOARDING or VALIDATION_ONLY).
+     * @returns A promise that resolves to the operation status.
+     */
+    async _initiateOperation(config, operationType, forExistingCategory) {
+        let existingOperation = await this._findExistingNonCompletedOperation(config.name, operationType);
+        if (existingOperation) {
+            // OnboardStatus has a lastUpdated field (ISO string)
+            // This field is updated by OnboardStatusManager.updateStatus
+            const fiveMinutesInMs = 5 * 60 * 1000;
+            const lastUpdateTimestamp = existingOperation.lastUpdated ? new Date(existingOperation.lastUpdated).getTime() : 0;
+            const currentTime = new Date().getTime();
+            if (lastUpdateTimestamp > 0 && (currentTime - lastUpdateTimestamp) > fiveMinutesInMs) {
+                Logger.log(`WARNING: [${existingOperation.onboardingId}] Found stale ${operationType} operation for feed: ${config.name} (last updated at: ${existingOperation.lastUpdated}). Proceeding to create a new operation.`);
+                existingOperation = undefined; // Treat as no existing operation for starting a new one
+            }
+            else {
+                Logger.log(`[${existingOperation.onboardingId}] Found existing non-completed ${operationType} operation for feed: ${config.name}. Returning its status.`);
+                return {
+                    onboardingId: existingOperation.onboardingId,
+                    status: existingOperation.status,
+                    message: `An ${operationType} process for this feed (${existingOperation.onboardingId}) is already in status: ${existingOperation.status}. Current step: ${existingOperation.currentStep || 'N/A'}`,
+                    lastQueried: new Date().toISOString(),
+                };
+            }
+        }
+        // serverName is removed
+        const initialStatus = await onboardStatusManager.createInitialStatus(config.name, operationType);
+        const onboardingId = initialStatus.onboardingId;
+        await onboardStatusManager.saveFeedConfiguration(onboardingId, config);
+        if (operationType === 'FULL_ONBOARDING') {
+            this.processFullOnboarding(onboardingId, config).catch(async (error) => {
+                Logger.error(`[${onboardingId}] Full feed onboarding process failed:`, error);
+                await onboardStatusManager.updateStatus(onboardingId, {
+                    status: OnboardingProcessStatus.FAILED,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    currentStep: 'Failed during full onboarding process',
+                    prInfo: undefined,
+                });
+            });
+        }
+        else if (operationType === 'VALIDATION_ONLY') {
+            this.processValidationOnly(onboardingId, config).catch(async (error) => {
+                Logger.error(`[${onboardingId}] Feed validation process failed:`, error);
+                await onboardStatusManager.updateStatus(onboardingId, {
+                    status: OnboardingProcessStatus.FAILED,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    currentStep: 'Failed during validation process',
+                    validationStatus: error.validationStatus || { isValid: false, message: error instanceof Error ? error.message : String(error) },
+                    prInfo: undefined,
+                });
+            });
+        }
+        return {
+            onboardingId,
+            status: OnboardingProcessStatus.PENDING,
+            message: `New ${operationType} process started with ID: ${onboardingId}.`,
+            lastQueried: new Date().toISOString(),
+        };
+    }
+    /**
+     * 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 allStatuses = await onboardStatusManager.getAllStatuses();
+        return Object.values(allStatuses).find((status) => status.feedName === feedName &&
+            // status.serverName === serverName && // serverName is removed
+            status.operationType === operationType &&
+            NON_COMPLETED_ONBOARDING_STATUSES.includes(status.status));
+    }
+    /**
+     * Performs static validation of the feed configuration.
+     * @param config The feed configuration to validate.
+     * @param forExistingCategory Whether this is for an existing category.
+     * @throws Error if validation fails.
+     */
+    async validateStaticConfig(config, forExistingCategory) {
+        // --- Start of moved and enhanced static validation ---
+        if (!config || typeof config !== 'object') { // Check if config itself is a valid object
+            throw new Error('Invalid configuration: Input must be a valid object.');
+        }
+        if (typeof config.name !== 'string' || !config.name.trim()) {
+            throw new Error('Invalid configuration: "name" must be a non-empty string.');
+        }
+        if (!Array.isArray(config.requirements)) {
+            throw new Error('Invalid configuration: "requirements" must be an array.');
+        }
+        if (!Array.isArray(config.mcpServers)) {
+            throw new Error('Invalid configuration: "mcpServers" must be an array.');
+        }
+        // --- End of moved static validation ---
+        const existingConfig = await configProvider.getFeedConfiguration(config.name);
+        if (forExistingCategory) {
+            if (!existingConfig) {
+                throw new Error(`Cannot update non-existent category: ${config.name}. Please ensure the category name is correct or create it as a new category.`);
+            }
+            // Original logic from existing validateStaticConfig:
+            // This implies that for an existing category, the payload must define mcpServers,
+            // and at least one of them must be new.
+            // If config.mcpServers is empty, newServersInPayload.length will be 0, leading to an error.
+            const existingServerNames = new Set(existingConfig.mcpServers.map((s) => s.name));
+            const newServersInPayload = config.mcpServers.filter((s) => !existingServerNames.has(s.name));
+            if (newServersInPayload.length === 0) {
+                // This error triggers if config.mcpServers is empty, or if all servers in config.mcpServers already exist.
+                throw new Error('No new servers provided for the existing category. Ensure the "mcpServers" list in your payload contains at least one server not already in this category, or that the list is not empty if you intend to add servers.');
+            }
+        }
+        else { // For new categories
+            if (existingConfig) {
+                throw new Error(`Category "${config.name}" already exists. To modify an existing category, please indicate that it is for an existing category.`);
+            }
+            if (!config.mcpServers || config.mcpServers.length === 0) {
+                throw new Error('Server configuration ("mcpServers") must be provided and non-empty for new categories.');
+            }
+        }
+    }
+    /**
+     * Validates the feed configuration.
+     * Updates the onboarding status to VALIDATING, then to VALIDATED or FAILED based on the validation result.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration to validate.
+     * @throws Error if validation fails, to be caught by the calling process.
+     */
+    async _validateFeedConfiguration(onboardingId, config) {
+        await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.VALIDATING, currentStep: 'Validating feed configuration' });
+        let overallValidationStatus = { isValid: true, serverResults: [] };
+        try {
+            feedValidator.validate(config);
+            // Then, validate each MCP server
+            for (const server of config.mcpServers) {
+                try {
+                    await feedValidator.validateServer(server, config);
+                    overallValidationStatus.serverResults?.push({ serverName: server.name, isValid: true });
+                    await onboardStatusManager.updateStatus(onboardingId, {
+                        currentStep: `Validated server: ${server.name}`,
+                        validationStatus: overallValidationStatus // Update with intermediate results
+                    });
+                }
+                catch (serverValidationError) {
+                    overallValidationStatus.isValid = false;
+                    overallValidationStatus.serverResults?.push({
+                        serverName: server.name,
+                        isValid: false,
+                        message: serverValidationError.message || String(serverValidationError)
+                    });
+                    // Update status immediately upon first server validation failure
+                    await onboardStatusManager.updateStatus(onboardingId, {
+                        status: OnboardingProcessStatus.FAILED,
+                        currentStep: `Validation failed for server: ${server.name}`,
+                        errorMessage: `Server ${server.name}: ${serverValidationError.message || String(serverValidationError)}`,
+                        validationStatus: overallValidationStatus
+                    });
+                    throw serverValidationError; // Propagate the error to fail the whole validation
+                }
+            }
+            // If all servers validated successfully
+            await onboardStatusManager.updateStatus(onboardingId, {
+                status: OnboardingProcessStatus.VALIDATED,
+                currentStep: 'All servers in feed configuration validated successfully',
+                validationStatus: overallValidationStatus
+            });
+        }
+        catch (error) {
+            const validationError = error; // Assuming error might have validation details
+            // This block will now primarily catch errors from the main feedValidator.validate(config)
+            // or if a server validation error was re-thrown and not caught by the loop's catch.
+            await onboardStatusManager.updateStatus(onboardingId, {
+                status: OnboardingProcessStatus.FAILED,
+                currentStep: 'Feed configuration validation failed',
+                errorMessage: validationError.message || String(error),
+                validationStatus: {
+                    isValid: false,
+                    message: validationError.message || String(error),
+                    serverResults: overallValidationStatus.serverResults // Include any server results gathered so far
+                }
+            });
+            throw error; // Re-throw to be caught by the calling process
+        }
+    }
+    /**
+     * Processes a validation-only operation for a feed configuration.
+     * It validates the configuration and updates the status to SUCCEEDED if validation is successful.
+     * If validation fails, the error is handled by _validateFeedConfiguration and the calling _initiateOperation method.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     */
+    async processValidationOnly(onboardingId, config, forExistingCategory) {
+        try {
+            await this._validateFeedConfiguration(onboardingId, config);
+            // _validateFeedConfiguration now handles setting VALIDATED or FAILED.
+            // If it completes without throwing, it means validation was successful.
+            const finalStatus = await onboardStatusManager.getStatus(onboardingId);
+            const result = {
+                validationStatus: finalStatus?.validationStatus || { isValid: true, serverResults: [] }, // Get the detailed status
+                feedConfiguration: config
+            };
+            await onboardStatusManager.updateStatus(onboardingId, {
+                status: OnboardingProcessStatus.SUCCEEDED, // Mark as SUCCEEDED for VALIDATION_ONLY
+                currentStep: 'Feed configuration validated successfully',
+                errorMessage: undefined,
+                prInfo: undefined,
+                result: result
+            });
+            Logger.log(`[${onboardingId}] Successfully validated feed: ${config.name}`);
+        }
+        catch (error) {
+            // Error handling is done within _validateFeedConfiguration and by the caller of processValidationOnly
+            Logger.error(`[${onboardingId}] Feed validation process failed for ${config.name}:`, error);
+            // No need to re-throw here as the caller's catch block will handle it.
+        }
+    }
+    /**
+     * Processes the full onboarding for a feed configuration.
+     * This includes validation, forking/cloning the repository, saving the config, and creating a pull request.
+     * Manages status updates throughout the process and handles cleanup of temporary directories.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     * @throws Error if any step of the full onboarding process fails.
+     */
+    async processFullOnboarding(onboardingId, config, forExistingCategory) {
+        const { tempDir, repoDir } = onboardProcessor.createDirectories(onboardingId);
+        try {
+            await this._validateFeedConfiguration(onboardingId, config);
+            await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Forking repository' });
+            await onboardProcessor.forkRepo(onboardingId, repoDir);
+            await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Cloning repository' });
+            await onboardProcessor.cloneRepo(onboardingId, tempDir, repoDir);
+            await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Setting up branch' });
+            const branchName = await onboardProcessor.setupBranch(onboardingId, config, repoDir);
+            await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Saving feed configuration to repository' });
+            await onboardProcessor.saveFeedConfigToRepo(onboardingId, config, repoDir);
+            await onboardStatusManager.updateStatus(onboardingId, { status: OnboardingProcessStatus.PR_CREATING, currentStep: 'Creating pull request' });
+            const prInfo = await onboardProcessor.createPullRequest(onboardingId, config, repoDir, branchName);
+            await onboardStatusManager.updateStatus(onboardingId, {
+                status: OnboardingProcessStatus.SUCCEEDED,
+                currentStep: 'Successfully onboarded',
+                errorMessage: undefined,
+                prInfo: prInfo,
+                result: prInfo.url
+            });
+            Logger.log(`[${onboardingId}] Successfully onboarded feed: ${config.name}`);
+        }
+        catch (error) {
+            Logger.error(`[${onboardingId}] Full feed onboarding failed:`, error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            let currentStep = 'Failed during full onboarding process';
+            if (error instanceof Error && 'step' in error) {
+                currentStep = `Failed at step: ${error.step}`;
+            }
+            else if ((await onboardStatusManager.getStatus(onboardingId))?.currentStep?.includes('validation failed')) {
+                throw error;
+            }
+            await onboardStatusManager.updateStatus(onboardingId, {
+                status: OnboardingProcessStatus.FAILED,
+                errorMessage: errorMessage,
+                currentStep: currentStep,
+            });
+            throw error;
+        }
+    }
+}
+// Export singleton instance
+export const feedOnboardService = new FeedOnboardService();
+//# sourceMappingURL=FeedOnboardService.js.map

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

@@ -0,0 +1,79 @@
+import { FeedConfiguration } from '../types.js';
+/**
+ * Class responsible for handling GitHub operations during the onboarding process
+ */
+export declare 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'.
+     */
+    forkRepo(onboardingId: string, repoDir: string): Promise<void>;
+    /**
+     * 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'.
+     */
+    cloneRepo(onboardingId: string, tempDir: string, repoDir: string): Promise<void>;
+    /**
+     * 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.
+     */
+    private getGitHubUsername;
+    /**
+     * 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'.
+     */
+    saveFeedConfigToRepo(onboardingId: string, config: FeedConfiguration, repoDir: string): Promise<void>;
+    /**
+     * 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.
+     */
+    setupBranch(onboardingId: string, config: FeedConfiguration, repoDir: string): Promise<string>;
+    /**
+     * 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.
+     */
+    createPullRequest(onboardingId: string, config: FeedConfiguration, repoDir: string, branchName: string): Promise<{
+        url: string;
+        branchName: string;
+    }>;
+    /**
+     * Creates necessary directories for the onboarding process
+     * @param onboardingId The ID of the onboarding process
+     * @returns Object containing tempDir and repoDir paths
+     */
+    createDirectories(onboardingId: string): {
+        tempDir: string;
+        repoDir: string;
+    };
+}
+export declare const onboardProcessor: OnboardProcessor;