imcp 0.1.6 → 0.1.8-dev

package/src/core/onboard/OnboardStatusManager.ts

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

package/src/core/validators/FeedValidator.ts

@@ -1,135 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { FeedConfiguration, McpConfig } from "../metadatas/types.js";
-import { serverValidatorFactory } from "./ServerValidatorFactory.js";
-import { Logger } from "../../utils/logger.js";
-import { onboardStatusManager } from "../onboard/OnboardStatusManager.js";
-import { OnboardingProcessStatus, OperationType } from "../onboard/OnboardStatus.js";
-
-/**
- * Validates feed configurations to ensure they meet required criteria
- */
-export 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
-   */
-  public async validate(config: FeedConfiguration, categoryName: string, operationType: OperationType): Promise<boolean> {
-    try {
-      await onboardStatusManager.recordStep(categoryName, operationType, `Starting feed validation for '${config.name}'`);
-      Logger.debug(`Validating feed configuration: ${config.name}`);
-
-      // Validate required fields
-      await onboardStatusManager.recordStep(categoryName, operationType, `Validating required fields for '${config.name}'`);
-      if (!config.name) throw new Error('Feed name is required');
-      if (!config.displayName) throw new Error('Feed display name is required');
-      if (!config.description) throw new Error('Feed description is required');
-
-      // Validate MCP servers array
-      await onboardStatusManager.recordStep(categoryName, operationType, `Validating MCP servers array for '${config.name}'`);
-      if (!Array.isArray(config.mcpServers) || config.mcpServers.length === 0) {
-        throw new Error('Feed must contain at least one MCP server');
-      }
-
-      // Validate requirements if present
-      if (config.requirements) {
-        await onboardStatusManager.recordStep(categoryName, operationType, `Validating requirements for '${config.name}'`);
-        for (const req of config.requirements) {
-          if (!req.name) throw new Error('Requirement name is required');
-          if (!req.type) throw new Error('Requirement type is required');
-          if (!req.version) throw new Error('Requirement version is required');
-        }
-      }
-
-      await onboardStatusManager.recordStep(categoryName, operationType, `Feed validation successful for '${config.name}'`, undefined, OnboardingProcessStatus.VALIDATING); // Still in progress until all servers validated
-      Logger.debug(`Feed configuration validation successful: ${config.name}`);
-      return true;
-    } catch (error) {
-      const errorMsg = `Feed validation failed for '${config.name}': ${error instanceof Error ? error.message : String(error)}`;
-      Logger.error(errorMsg);
-      await onboardStatusManager.recordStep(categoryName, operationType, `Feed validation failed for '${config.name}'`, undefined, OnboardingProcessStatus.FAILED, errorMsg);
-      throw new Error(errorMsg);
-    }
-  }
-
-  /**
-   * 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
-   */
-  public async validateServer(server: McpConfig, config: FeedConfiguration, categoryName: string, operationType: OperationType): Promise<boolean> {
-    const feedName = config.name; // categoryName is the feedName in this context
-    const serverDisplayName = server.name;
-
-    try {
-      await onboardStatusManager.recordStep(categoryName, operationType, `Starting server validation for '${serverDisplayName}' in feed '${feedName}'`, server.name);
-      Logger.debug(`Validating server configuration: ${serverDisplayName} in feed ${feedName}`);
-
-      // Validate basic required fields
-      await onboardStatusManager.recordStep(categoryName, operationType, `Validating basic fields for server '${serverDisplayName}'`, server.name);
-      if (!server.name) throw new Error('Server name is required');
-      if (!server.description) throw new Error('Server description is required');
-      if (!server.mode) throw new Error('Server mode is required');
-      if (!server.installation) throw new Error('Server installation configuration is required');
-
-      // Validate schema file existence if schemas is defined
-      if (server.schemas) {
-        await onboardStatusManager.recordStep(categoryName, operationType, `Validating schema file for server '${serverDisplayName}'`, server.name);
-        try {
-          // Assuming server.schemas is a relative path from the project root or a path that needs to be resolved.
-          // For now, let's assume it's relative to the feed file's location or an absolute path.
-          // If it's relative to the feed file, we might need the feed file's path.
-          // For simplicity, let's assume it's a path that can be directly accessed.
-          // If the schema path is relative to the feed config file, this logic will need adjustment.
-          // For now, we'll treat it as a path that `fs.access` can check.
-          // It's more likely that schema paths are relative to the feed definition file itself.
-          // However, the task description implies `server.schemas` is a path to be checked.
-          // Let's assume for now it's a path that should exist.
-          // If the schemas are stored within the repo, their paths would be relative to the repo root.
-          // During validation, we might not have the repo context directly here.
-          // This needs clarification on how schema paths are resolved during validation.
-          // For now, we'll proceed with a direct check.
-          // If the schema is part of the feed package, its path might be relative to the package root.
-          // Let's assume the path is resolvable from the current working directory or is absolute.
-          // This part might need refinement based on where schema files are expected to be.
-          // The task implies `server.schemas` is a string path.
-          const schemaPath = server.schemas; // This path needs to be correctly resolved.
-          // If it's relative to the feed file, we need that context.
-          // For now, we'll assume it's a path that can be checked.
-          // This might be an issue if it's relative to a file not yet in the repo.
-          // Let's assume it's a path that should be resolvable.
-          await fs.access(schemaPath);
-          Logger.debug(`Schema file ${schemaPath} exists for server ${serverDisplayName}`);
-        } catch (fileAccessError) {
-          throw new Error(`Schema file '${server.schemas}' not found for server '${serverDisplayName}'.`);
-        }
-      }
-
-      // Get the appropriate validator for this server type
-      await onboardStatusManager.recordStep(categoryName, operationType, `Obtaining specific validator for server '${serverDisplayName}'`, server.name);
-      const validator = serverValidatorFactory.getValidatorForServer(server);
-
-      // Perform mode-specific validation with feed config
-      await onboardStatusManager.recordStep(categoryName, operationType, `Performing mode-specific validation for server '${serverDisplayName}'`, server.name);
-      await validator.validateServer(server, config); // This internal call won't have status updates unless modified too
-
-      await onboardStatusManager.recordStep(categoryName, operationType, `Server validation successful for '${serverDisplayName}'`, server.name, OnboardingProcessStatus.VALIDATING); // Still in progress until all servers validated
-      Logger.debug(`Server configuration validation successful: ${serverDisplayName}`);
-      return true;
-    } catch (error) {
-      const errorMsg = `Server validation failed for '${serverDisplayName}' in feed '${feedName}': ${error instanceof Error ? error.message : String(error)}`;
-      Logger.error(errorMsg);
-      await onboardStatusManager.recordStep(categoryName, operationType, `Server validation failed for '${serverDisplayName}'`, server.name, OnboardingProcessStatus.FAILED, errorMsg);
-      throw new Error(errorMsg);
-    }
-  }
-}
-
-// Export singleton instance
-export const feedValidator = new FeedValidator();

package/src/core/validators/IServerValidator.ts

@@ -1,21 +0,0 @@
-import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
-
-/**
- * Interface for MCP server configuration validators
- * Defines common validation operations for server configurations
- */
-export interface IServerValidator {
-  /**
-   * Validates a specific MCP server configuration
-   * Implementation varies based on server mode (stdio/sse)
-   * @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>;
-}
-
-/**
- * Valid validator types for MCP servers
- */
-export type ValidatorType = 'stdio' | 'sse';

package/src/core/validators/SSEServerValidator.ts

@@ -1,43 +0,0 @@
-import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
-import { IServerValidator } from "./IServerValidator.js";
-import { Logger } from "../../utils/logger.js";
-
-/**
- * Validates MCP server configurations for SSE mode
- */
-export class SSEServerValidator implements IServerValidator {
-  /**
-   * Validates SSE-specific MCP server configuration
-   * Checks installation URL, requirements, and environment variables
-   * @param server The MCP server configuration to validate
-   * @param config The feed configuration containing shared requirements
-   * @returns true if valid, throws error if invalid
-   */
-  public async validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean> {
-    try {
-      Logger.debug(`Validating SSE server configuration: ${server.name}`);
-
-      if (!server.installation?.url) {
-        throw new Error('SSE server URL is required in installation configuration');
-      }
-
-      try {
-        new URL(server.installation.url);
-      } catch (e) {
-        throw new Error(`Invalid SSE server URL: ${server.installation.url}`);
-      }
-
-      // Validate server mode
-      if (server.mode !== 'sse') {
-        throw new Error(`Invalid server mode for SSE validator: ${server.mode}`);
-      }
-
-      // Additional SSE-specific validation will be implemented later
-      return true;
-    } catch (error) {
-      const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
-      Logger.error(errorMsg);
-      throw new Error(errorMsg);
-    }
-  }
-}

package/src/core/validators/ServerValidatorFactory.ts

@@ -1,51 +0,0 @@
-import { McpConfig } from "../metadatas/types.js";
-import { IServerValidator, ValidatorType } from "./IServerValidator.js";
-import { StdioServerValidator } from "./StdioServerValidator.js";
-import { SSEServerValidator } from "./SSEServerValidator.js";
-import { Logger } from "../../utils/logger.js";
-
-/**
- * Factory class for managing server validator instances
- * Maintains a singleton map of validators by type
- */
-export class ServerValidatorFactory {
-  private static validators = new Map<ValidatorType, IServerValidator>();
-
-  constructor() {
-    // Initialize validators if not already done
-    if (ServerValidatorFactory.validators.size === 0) {
-      Logger.debug('Initializing server validators');
-      ServerValidatorFactory.validators.set('stdio', new StdioServerValidator());
-      ServerValidatorFactory.validators.set('sse', new SSEServerValidator());
-    }
-  }
-
-  /**
-   * Gets the appropriate validator for the given server mode
-   * @param mode The server mode to get validator for
-   * @returns IServerValidator instance for the specified mode
-   * @throws Error if server mode is not supported
-   */
-  public getValidator(mode: ValidatorType): IServerValidator {
-    const validator = ServerValidatorFactory.validators.get(mode);
-    if (!validator) {
-      const error = `Unsupported MCP server mode: ${mode}`;
-      Logger.error(error);
-      throw new Error(error);
-    }
-    Logger.debug(`Retrieved ${mode} validator`);
-    return validator;
-  }
-
-  /**
-   * Gets the appropriate validator for the given server config
-   * @param serverConfig MCP server configuration
-   * @returns IServerValidator instance appropriate for the server mode
-   */
-  public getValidatorForServer(serverConfig: McpConfig): IServerValidator {
-    return this.getValidator(serverConfig.mode);
-  }
-}
-
-// Export singleton instance
-export const serverValidatorFactory = new ServerValidatorFactory();