imcp 0.0.14 → 0.0.16

package/src/core/onboard/OnboardStatus.ts

@@ -0,0 +1,55 @@
+import { FeedConfiguration } from "../types.js";
+
+export 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; // e.g., "Validating feed configuration", "Forking repository"
+  validationStatus?: {
+    isValid: boolean;
+    message?: string;
+    serverResults?: ServerValidationResult[];
+  };
+  prInfo?: {
+    url?: string;
+    branchName?: string;
+  };
+  result?: any; // Can store PR URL or other relevant result data
+  errorMessage?: string;
+  lastUpdated: string;
+  feedName: string;
+  serverName?: string; // Optional, if applicable
+  operationType?: OperationType;
+}
+
+export interface OperationStatus {
+  onboardingId: string;
+  status: OnboardingProcessStatus;
+  message?: string;
+  lastQueried?: string; // ISO date string of when the status was last queried by a client
+}
+
+export interface ValidationOperationResult {
+  validationStatus: {
+    isValid: boolean;
+    message?: string;
+    serverResults?: ServerValidationResult[];
+  };
+  feedConfiguration?: FeedConfiguration;
+}

package/src/core/onboard/OnboardStatusManager.ts

@@ -0,0 +1,188 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SETTINGS_DIR } from '../constants.js';
+import { FeedConfiguration } from '../types.js';
+import { OnboardStatus, OnboardingProcessStatus, OperationType } from './OnboardStatus.js';
+import { Logger } from '../../utils/logger.js';
+
+const ONBOARD_STATUS_DIR = path.join(SETTINGS_DIR, 'onboard');
+const CATEGORY_OPERATIONS_STATUS_FILE = path.join(ONBOARD_STATUS_DIR, 'category_operations_status.json');
+const FEED_CONFIG_DIR = path.join(ONBOARD_STATUS_DIR, 'feed_configs'); // Staging for feed configs during operation
+
+export class OnboardStatusManager {
+  private static instance: OnboardStatusManager;
+  private activeCategoryOperations: Record<string, 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, config: FeedConfiguration): Promise<void> {
+    await this.withLock(async () => {
+      try {
+        await fs.mkdir(FEED_CONFIG_DIR, { recursive: true });
+        // Suffix `_feed.json` to distinguish from potential status files if names overlap
+        const configPath = path.join(FEED_CONFIG_DIR, `${categoryName}_feed.json`);
+        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): Promise<FeedConfiguration | undefined> {
+    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) 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 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.
+   */
+  public async getStatus(categoryName: string): Promise<OnboardStatus | undefined> {
+    await this.loadStatuses(); // Ensure latest statuses are loaded (though constructor does it initially)
+    return this.activeCategoryOperations[categoryName];
+  }
+
+  /**
+   * Retrieves all active category operation statuses.
+   * @returns A promise that resolves to a record of all active OnboardStatus objects, keyed by categoryName.
+   */
+  public async getAllStatuses(): Promise<Record<string, OnboardStatus>> {
+    await this.loadStatuses();
+    return this.activeCategoryOperations;
+  }
+
+  /**
+   * Updates the status of a category's active operation.
+   * If no operation exists for the category, it might create one based on the updates,
+   * or fail if `onboardingId` (categoryName) is not present in `newStatus`.
+   * For clarity, it's better if `createInitialStatus` is called first.
+   * @param categoryName The name of the category (acting as operationId).
+   * @param updates Partial OnboardStatus object with fields to update.
+   * @returns A promise that resolves to the updated OnboardStatus.
+   */
+  public async updateStatus(categoryName: string, updates: Partial<OnboardStatus>): Promise<OnboardStatus> {
+    return await this.withLock(async () => {
+      const existingStatus = this.activeCategoryOperations[categoryName] || {
+        onboardingId: categoryName, // Ensure onboardingId is set to categoryName if creating new
+        feedName: categoryName,    // Ensure feedName is set to categoryName
+        status: OnboardingProcessStatus.PENDING, // Default status if creating new
+        lastUpdated: new Date().toISOString(),
+        operationType: updates.operationType || 'FULL_ONBOARDING', // Default operation type
+        ...updates // Apply initial updates if creating new
+      };
+
+      const updatedStatus: OnboardStatus = {
+        ...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.
+   */
+  public async createInitialStatus(categoryName: string, operationType: OperationType, serverName?: string): Promise<OnboardStatus> {
+    // The operationId is the categoryName itself for category-wide operations.
+    const operationId = categoryName;
+
+    const initialStatus: OnboardStatus = {
+      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();

package/src/core/types.ts

@@ -18,11 +18,13 @@ export interface RequirementStatus {
   lastCheckTime?: string;
   operationStatus?: OperationStatus;
   pythonEnv?: string; // Store Python environment path for pip requirements
+  npmPath?: string; // Path to the installed npm package path
 }
 
 export interface MCPServerStatus {
   installedStatus: Record<string, OperationStatus>; // client: installed
   name: string;
+  tags?: string[];
   error?: string;
 }
 
@@ -46,6 +48,7 @@ export interface MCPServerCategory {
   displayName: string;
   description?: string;
   type: 'local';
+  tags?: string[];
   path?: string;
   installationStatus?: InstallationStatus;
   feedConfiguration?: FeedConfiguration;
@@ -131,12 +134,8 @@ export interface RegistryConfig {
   };
   artifacts?: {
     registryUrl: string;
-    assetName?: string; // Template string like "ai-coder-tools-${latest}.tgz"
+    registryName: string; // Name of the registry
   };
-  local?: {
-    localPath: string; // Local path for local registry
-    assetName?: string; // Template string like "ai-coder-tools-${latest}.tgz"
-  }
 }
 
 export interface RequirementConfig {

package/src/core/validators/FeedValidator.ts

@@ -0,0 +1,79 @@
+import { FeedConfiguration, McpConfig } from "../types.js";
+import { serverValidatorFactory } from "./ServerValidatorFactory.js";
+import { Logger } from "../../utils/logger.js";
+
+/**
+ * Validates feed configurations to ensure they meet required criteria
+ */
+export class FeedValidator {
+  /**
+   * Validates a feed configuration
+   * @param config The feed configuration to validate
+   * @returns true if valid, throws error if invalid
+   */
+  public validate(config: FeedConfiguration): boolean {
+    try {
+      Logger.debug(`Validating feed configuration: ${config.name}`);
+
+      // Validate required fields
+      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
+      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) {
+        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');
+        }
+      }
+
+      Logger.debug(`Feed configuration validation successful: ${config.name}`);
+      return true;
+    } catch (error) {
+      const errorMsg = `Feed validation failed: ${error instanceof Error ? error.message : String(error)}`;
+      Logger.error(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
+   * @returns true if valid, throws error if invalid
+   */
+  public async validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean> {
+    try {
+      Logger.debug(`Validating server configuration: ${server.name}`);
+
+      // Validate basic required fields
+      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');
+
+      // Get the appropriate validator for this server type
+      const validator = serverValidatorFactory.getValidatorForServer(server);
+      
+      // Perform mode-specific validation with feed config
+      await validator.validateServer(server, config);
+
+      Logger.debug(`Server configuration validation successful: ${server.name}`);
+      return true;
+    } catch (error) {
+      const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
+      Logger.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+  }
+}
+
+// Export singleton instance
+export const feedValidator = new FeedValidator();

package/src/core/validators/IServerValidator.ts

@@ -0,0 +1,21 @@
+import { McpConfig, FeedConfiguration } from "../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

@@ -0,0 +1,43 @@
+import { McpConfig, FeedConfiguration } from "../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

@@ -0,0 +1,51 @@
+import { McpConfig } from "../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();