imcp 0.0.19 → 0.1.2

package/src/core/metadatas/recordingConstants.ts

@@ -0,0 +1,62 @@
+/**
+ * Step name constants for InstallOperationManager and step recording.
+ *
+ * This file defines all static step names and documents dynamic step name patterns
+ * used throughout the installation and onboarding process.
+ *
+ * Dynamic step names are documented as template string patterns.
+ */
+
+/** Step for processing all requirement updates in a batch operation. */
+export const STEP_PROCESS_REQUIREMENT_UPDATES = 'Processing all requirement updates';
+
+/** Step for checking the status of a specific requirement. */
+export const STEP_CHECKING_REQUIREMENT_STATUS = 'Checking the status of requirement';
+
+/** Step for installing requirements in the background process. */
+export const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = 'Installing requirements in the background';
+
+/** Step for checking and installing all requirements as needed. */
+export const STEP_CHECK_AND_INSTALL_REQUIREMENTS = 'Checking and installing all requirements';
+
+/** Step for running the install logic in the CommandInstaller. */
+export const STEP_COMMAND_INSTALLER_INSTALL = 'Running install in CommandInstaller';
+
+/** Step for running the install logic in the GeneralInstaller. */
+export const STEP_GENERAL_INSTALLER_INSTALL = 'Running install in GeneralInstaller';
+
+/** Step for executing the actual installation command (npm, pip, etc.). */
+export const STEP_INSTALLATION_COMMAND_EXECUTION = 'Executing installation command for requirement';
+
+/** Step for running the install logic in the PipInstaller. */
+export const STEP_PIP_INSTALLER_INSTALL = 'Running install in PipInstaller';
+
+/** Step for processing requirement updates in the RequirementService. */
+export const STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE = 'Processing requirement updates in RequirementService';
+
+/** Step for checking if the server is ready after installation. */
+export const STEP_CHECK_SERVER_READINESS = 'Checking server readiness after installation';
+
+/** Step for running the install logic in the NpmInstaller. */
+export const STEP_NPM_INSTALLER_INSTALL = 'Running install in NpmInstaller';
+
+/** Prefix for steps that update a specific requirement. */
+export const STEP_INSTALL_REQUIREMENT_PREFIX = 'Updating requirement:';
+
+/** Prefix for steps that execute an installation command for a requirement. */
+export const STEP_INSTALL_COMMAND_PREFIX = 'Executing installation command for:';
+
+/** Step for checking and installing the VS Code extension for the client. */
+export const STEP_CHECK_VSCODE_AND_INSTALL_EXTENSION = 'Checking and installing VS Code extension for client';
+
+/** Step for setting up the installation configuration (env, args, etc.). */
+export const STEP_SETUP_INSTALLATION_CONFIG = 'Setting up installation configuration';
+
+/** Step for updating VS Code settings for the client/server. */
+export const STEP_UPDATE_VSCODE_SETTINGS = 'Updating VS Code settings for client/server';
+
+/** Step for the overall installation process of a client or server. */
+export const STEP_INSTALLATION = 'Running overall installation process';
+
+/** Step for marking the initiation of an onboarding or installation process. */
+export const STEP_INITIATED = 'Initiating onboarding or installation process';

package/src/core/metadatas/types.ts

@@ -176,4 +176,27 @@ export interface MCPEventData {
   [MCPEvent.SERVER_STARTED]: { server: MCPServerCategory };
   [MCPEvent.SERVER_STOPPED]: { serverName: string };
   [MCPEvent.CONFIG_CHANGED]: { configuration: MCPConfiguration };
+}
+
+export interface InstallOperationStep {
+  name: string;
+  status: 'pending' | 'in-progress' | 'completed' | 'failed' | 'canceled';
+  message?: string;
+  isCritical?: boolean;
+  timestamp: string;
+}
+
+export interface InstallOperationDetails {
+  currentStep: string;
+  steps: InstallOperationStep[];
+  lastUpdated: string;
+  error?: string;
+  overallStatus: 'pending' | 'in-progress' | 'completed' | 'failed';
+}
+export interface SystemSettings {
+  pythonEnvs?: Record<string, string>;
+  nodePath?: string;
+  browserPath?: string;
+  systemEnvironments?: Record<string, string>;
+  userConfigurations?: Record<string, string>;
 }

package/src/core/onboard/FeedOnboardService.ts

@@ -2,7 +2,7 @@ import { FeedConfiguration, McpConfig } from '../metadatas/types.js';
 import { configProvider } from '../loaders/ConfigurationProvider.js';
 import { ServerSchemaProvider } from '../loaders/ServerSchemaProvider.js';
 import { feedValidator } from '../validators/FeedValidator.js';
-import { Logger } from '../../utils/logger.js';
+import { Logger, EventType, EventStatus } from '../../utils/logger.js';
 import { OnboardingProcessStatus, OperationStatus, OperationType, ValidationOperationResult } from './OnboardStatus.js';
 import { onboardStatusManager } from './OnboardStatusManager.js';
 import { onboardProcessor } from './OnboardProcessor.js';
@@ -28,8 +28,10 @@ export class FeedOnboardService {
   }
 
   /**
-   * Onboard a new feed configuration
+   * Onboard a new feed configuration. This method performs validation and initiates the onboarding process.
    * @param config Feed configuration to onboard
+   * @param forExistingCategory Whether this onboarding is for an existing category
+   * @returns Promise resolving to operation status with optional feed configuration
    */
   public async onboardFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
     // Perform static validation first
@@ -47,10 +49,21 @@ export class FeedOnboardService {
       // For now, let's return a FAILED status for the attempted FULL_ONBOARDING initiation.
       // A more robust solution might involve a different return type or error code.
       const onboardingId = this.createOperationId(config.name, 'FULL_ONBOARDING'); // Hypothetical ID
+      const errorMessage = `No prior successful validation found for feed: ${config.name}. Please validate the configuration before publishing.`;
+      
+      // Track failed event
+      Logger.trackEvent(EventType.FEED_ONBOARD, {
+        status: EventStatus.FAILED,
+        feedName: config.name,
+        errorMessage,
+        onboardingId: onboardingId,
+        feedConfiguration: config
+      });
+      
       return {
         onboardingId: onboardingId,
         status: OnboardingProcessStatus.FAILED, // Or a new status like 'VALIDATION_REQUIRED'
-        message: 'The feed configuration has not been validated or has changed. Please validate the configuration before publishing.',
+        message: errorMessage,
         lastQueried: new Date().toISOString(),
         feedConfiguration: config
       };
@@ -60,6 +73,7 @@ export class FeedOnboardService {
     // If validation exists and matches, proceed to initiate FULL_ONBOARDING.
     // _initiateOperation will handle checks for existing non-completed or successfully completed FULL_ONBOARDING operations.
     const operationStatus = await this._initiateOperation(config, 'FULL_ONBOARDING', serverList, forExistingCategory);
+
     return {
       ...operationStatus,
       feedConfiguration: config
@@ -67,9 +81,11 @@ export class FeedOnboardService {
   }
 
   /**
-   * Validate a feed configuration without performing full onboarding
+   * Validate a feed configuration without performing full onboarding.
+   * This method performs static validation and initiates the validation process.
    * @param config Feed configuration to validate
-   * @returns Operation status indicating the result of the validation initiation
+   * @param forExistingCategory Whether this validation is for an existing category
+   * @returns Promise resolving to operation status with optional feed configuration
    */
   public async validateFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
     // Perform static validation first
@@ -365,9 +381,29 @@ export class FeedOnboardService {
         validationStatus: result.validationStatus // Ensure validationStatus is also updated on success
       });
       Logger.log(`[${onboardingId}] Successfully validated feed: ${config.name}`);
+
+      // Track successful validation
+      Logger.trackEvent(EventType.FEED_VALIDATE, {
+        status: EventStatus.SUCCESS,
+        feedName: config.name,
+        operationType: 'VALIDATION_ONLY',
+        onboardingId: onboardingId,
+        feedConfiguration: config
+      });
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       // Error is already logged and status updated by _validateFeedConfiguration or its callers
       Logger.error(`[${onboardingId}] Feed validation process failed for ${config.name} (already handled):`, error);
+      
+      // Track validation failure
+      Logger.trackEvent(EventType.FEED_VALIDATE, {
+        status: EventStatus.FAILED,
+        feedName: config.name,
+        operationType: 'VALIDATION_ONLY',
+        errorMessage: errorMessage,
+        onboardingId: onboardingId,
+        feedConfiguration: config
+      });
     }
   }
 
@@ -428,6 +464,15 @@ export class FeedOnboardService {
         Logger.log(`[${onboardingId}] ConfigurationProvider re-initialized.`);
 
         Logger.log(`[${onboardingId}] Successfully completed full onboarding for feed: ${config.name}`);
+
+        // Track successful onboarding
+        Logger.trackEvent(EventType.FEED_ONBOARD, {
+          status: EventStatus.SUCCESS,
+          feedName: config.name,
+          onboardingId: onboardingId,
+          prUrl: prInfo.url,
+          feedConfiguration: config
+        });
       } catch (reinitError) {
         Logger.warn(`[${onboardingId}] Failed to re-initialize providers after PR creation for feed ${config.name}:`);
         Logger.warn(`Skipping re-initialization of providers due to error: ${reinitError}`,);
@@ -437,6 +482,15 @@ export class FeedOnboardService {
       Logger.error(`[${onboardingId}] Full feed onboarding process failed:`, error);
       const errorMessage = error instanceof Error ? error.message : String(error);
 
+      // Track onboarding failure
+      Logger.trackEvent(EventType.FEED_ONBOARD, {
+        status: EventStatus.FAILED,
+        feedName: config.name,
+        onboardingId: onboardingId,
+        errorMessage,
+        feedConfiguration: config
+      });
+
       // Check if status is already FAILED (e.g., by _validateFeedConfiguration)
       // to avoid overwriting a more specific error message or step from validation.
       const currentStatus = await onboardStatusManager.getStatus(config.name, operationType);

package/src/core/onboard/OnboardStatusManager.ts

@@ -5,6 +5,7 @@ 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
@@ -306,7 +307,7 @@ export class OnboardStatusManager {
       feedName: categoryName,
       serverName,
       status: OnboardingProcessStatus.PENDING,
-      steps: [{ stepName: 'Initiated', timestamp: new Date().toISOString() }],
+      steps: [{ stepName: RecordingConstants.STEP_INITIATED, timestamp: new Date().toISOString() }],
       lastUpdated: new Date().toISOString(),
       operationType,
       errorMessage: undefined,

package/src/core/validators/StdioServerValidator.ts

@@ -8,6 +8,7 @@ import { MACRO_EXPRESSIONS, resolveNpmModulePath } from "../../utils/macroExpres
 import { getSystemPythonPackageDirectory } from "../../utils/osUtils.js";
 import { SETTINGS_DIR } from "../metadatas/constants.js";
 import path from "path";
+import { InstallOperationManager } from "../loaders/InstallOperationManager.js";
 
 const execPromise = util.promisify(exec);
 
@@ -57,7 +58,7 @@ export class StdioServerValidator implements IServerValidator {
    * @param requirement The requirement config to validate and install
    * @returns true if requirement is successfully installed/validated
    */
-  private async validateRequirement(requirement: RequirementConfig): Promise<boolean> {
+  private async validateRequirement(requirement: RequirementConfig, recorder: InstallOperationManager): Promise<boolean> {
     try {
       Logger.debug(`Validating/installing requirement: ${requirement.name}`);
       const installer = this.installerFactory.getInstaller(requirement);
@@ -69,7 +70,7 @@ export class StdioServerValidator implements IServerValidator {
       }
 
       const targetDir = this._getRequirementFolderPath(requirement);
-      const status = await installer.install(requirement, { settings: { folderName: targetDir } });
+      const status = await installer.install(requirement, recorder, { settings: { folderName: targetDir } });
       if (!status.installed) {
         const msg = `Failed to install requirement ${requirement.name}: ${status.error || 'Unknown error'}`;
         Logger.error(msg);
@@ -288,7 +289,7 @@ export class StdioServerValidator implements IServerValidator {
             type: 'npm' // Default to npm if not specified
           };
 
-          const isValid = await this.validateRequirement(reqConfig);
+          const isValid = await this.validateRequirement(reqConfig, InstallOperationManager.getInstance(config.name, server.name));
           if (!isValid) {
             throw new Error(`Dependency validation failed for: ${req.name}`);
           }