imcp 0.0.19 → 0.1.2

package/dist/core/loaders/SystemSettingsManager.js

@@ -0,0 +1,257 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SETTINGS_DIR } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { getSystemPythonExecutablePath, getNpmExecutablePath, getBrowserPath } from '../../utils/osUtils.js';
+const SETTINGS_FILE_NAME = 'system_settings.json';
+const SETTINGS_FILE_PATH = path.join(SETTINGS_DIR, 'settings', SETTINGS_FILE_NAME);
+export class SystemSettingsManager {
+    static instance;
+    settings;
+    settingsFilePath;
+    settingsLock = Promise.resolve();
+    constructor() {
+        this.settingsFilePath = SETTINGS_FILE_PATH;
+        this.settings = {};
+        // No await here, initialization is best-effort. Lock will protect subsequent calls.
+        this.loadSettings().catch(error => {
+            Logger.error('Failed to initialize SystemSettingsManager during construction:', error);
+            // Initialize with empty settings if load fails, defaults will be applied on first access
+            this.settings = {};
+        });
+    }
+    static getInstance() {
+        if (!SystemSettingsManager.instance) {
+            SystemSettingsManager.instance = new SystemSettingsManager();
+        }
+        return SystemSettingsManager.instance;
+    }
+    async withLock(operation) {
+        const currentLock = this.settingsLock;
+        let releaseLock;
+        this.settingsLock = new Promise(resolve => releaseLock = resolve);
+        try {
+            await currentLock;
+            return await operation();
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    // Internal method without lock
+    async _loadSettingsInternal() {
+        try {
+            await fs.mkdir(path.dirname(this.settingsFilePath), { recursive: true });
+            const data = await fs.readFile(this.settingsFilePath, 'utf-8');
+            this.settings = JSON.parse(data);
+            await this._applyDefaultsIfNeededInternal(); // Call internal version
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                Logger.info(`Settings file not found at ${this.settingsFilePath}. Initializing with defaults.`);
+                this.settings = {};
+                await this._applyDefaultsIfNeededInternal(); // Call internal version
+            }
+            else {
+                Logger.error(`Error loading settings from ${this.settingsFilePath}:`, error);
+                this.settings = {};
+                await this._applyDefaultsIfNeededInternal(); // Call internal version
+            }
+        }
+    }
+    /**
+     * Loads settings from the file. This operation is atomic.
+     * If the settings file doesn't exist, it initializes with defaults and creates the file.
+     * @returns A promise that resolves when settings are loaded.
+     */
+    async loadSettings() {
+        return this.withLock(() => this._loadSettingsInternal());
+    }
+    // Internal method without lock
+    async _applyDefaultsIfNeededInternal() {
+        let updated = false;
+        const normalizePath = (p) => p ? p.replace(/\\/g, '/') : undefined;
+        if (!this.settings.pythonEnvs) {
+            this.settings.pythonEnvs = {};
+            updated = true;
+        }
+        if (!this.settings.pythonEnvs["system"]) {
+            try {
+                const pythonPath = normalizePath(await getSystemPythonExecutablePath() || undefined);
+                if (pythonPath) {
+                    this.settings.pythonEnvs["system"] = pythonPath;
+                    updated = true;
+                }
+            }
+            catch (e) {
+                Logger.warn(`Could not get default pythonEnv: ${e}`);
+            }
+        }
+        if (!this.settings.nodePath) {
+            try {
+                const npmExecDir = await getNpmExecutablePath();
+                let nodeExecutable = process.platform === 'win32' ? 'node.exe' : 'node';
+                const platformNodePath = process.platform === 'win32'
+                    ? path.join(npmExecDir || '', nodeExecutable)
+                    : path.join(npmExecDir || '', 'bin', nodeExecutable);
+                this.settings.nodePath = npmExecDir ? normalizePath(platformNodePath) : undefined;
+                if (this.settings.nodePath)
+                    updated = true;
+            }
+            catch (e) {
+                Logger.warn(`Could not get default nodePath: ${e}`);
+            }
+        }
+        else {
+            this.settings.nodePath = normalizePath(this.settings.nodePath);
+        }
+        if (!this.settings.browserPath) {
+            try {
+                this.settings.browserPath = normalizePath(await getBrowserPath() || undefined);
+                if (this.settings.browserPath)
+                    updated = true;
+            }
+            catch (e) {
+                Logger.warn(`Could not get default browserPath: ${e}`);
+            }
+        }
+        else {
+            this.settings.browserPath = normalizePath(this.settings.browserPath);
+        }
+        if (!this.settings.systemEnvironments) {
+            this.settings.systemEnvironments = { ...process.env };
+            updated = true;
+        }
+        if (this.settings.userConfigurations === undefined) {
+            this.settings.userConfigurations = {};
+            updated = true;
+        }
+        if (updated) {
+            await this._saveSettingsInternal();
+        }
+    }
+    /**
+     * Applies default values to settings if they are not already set.
+     * This operation is atomic and saves settings if defaults are applied.
+     * @returns A promise that resolves when defaults are applied and saved if necessary.
+     */
+    async applyDefaultsIfNeeded() {
+        return this.withLock(() => this._applyDefaultsIfNeededInternal());
+    }
+    /**
+     * Retrieves the current system settings.
+     * If settings haven't been loaded or are empty, it attempts to load them.
+     * Paths within the settings are normalized (e.g., backslashes to forward slashes).
+     * @returns A promise that resolves to the `SystemSettings` object.
+     */
+    async getSystemSettings() {
+        // Ensure settings are loaded if they are empty.
+        if (Object.keys(this.settings).length === 0) {
+            // Use the public, locked version of loadSettings here
+            await this.loadSettings();
+        }
+        // Return a deep copy to prevent external modification of the internal state.
+        // Ensure this.settings is used, not a potentially stale local copy.
+        const settingsToReturn = JSON.parse(JSON.stringify(this.settings));
+        // Ensure paths are normalized when retrieved
+        const normalizedSettings = { ...settingsToReturn };
+        // Normalize paths in pythonEnvs
+        if (normalizedSettings.pythonEnvs) {
+            const normalizedPythonEnvs = {};
+            Object.keys(normalizedSettings.pythonEnvs).forEach(key => {
+                normalizedPythonEnvs[key] = normalizedSettings.pythonEnvs?.[key]?.replace(/\\/g, '/') || '';
+            });
+            normalizedSettings.pythonEnvs = normalizedPythonEnvs;
+        }
+        normalizedSettings.nodePath = normalizedSettings.nodePath?.replace(/\\/g, '/');
+        normalizedSettings.browserPath = normalizedSettings.browserPath?.replace(/\\/g, '/');
+        return normalizedSettings;
+    }
+    /**
+     * Creates or updates system settings with the provided partial settings.
+     * This operation is atomic and protected by a lock.
+     * It loads existing settings if not already loaded, merges the new settings,
+     * applies any necessary defaults, and then saves the updated settings.
+     * @param newSettings A `Partial<SystemSettings>` object containing the settings to update.
+     * @returns A promise that resolves to the fully updated and normalized `SystemSettings`.
+     */
+    async createOrUpdateSystemSettings(newSettings) {
+        return this.withLock(async () => {
+            // Ensure current settings are loaded before modification by calling the internal, non-locking version
+            if (Object.keys(this.settings).length === 0) {
+                await this._loadSettingsInternal();
+            }
+            const normalizePath = (p) => p ? p.replace(/\\/g, '/') : undefined;
+            // Initialize pythonEnvs if it doesn't exist on the current settings
+            if (!this.settings.pythonEnvs) {
+                this.settings.pythonEnvs = {};
+            }
+            // Create a new settings object by merging current and new settings.
+            const updatedSettings = {
+                ...this.settings, // Start with current settings
+                ...newSettings, // Override with new settings
+                // Explicitly handle potentially undefined paths from newSettings
+                nodePath: normalizePath(newSettings.nodePath !== undefined ? newSettings.nodePath : this.settings.nodePath),
+                browserPath: normalizePath(newSettings.browserPath !== undefined ? newSettings.browserPath : this.settings.browserPath),
+                // Ensure systemEnvironments and userConfigurations are properly merged or taken from newSettings
+                systemEnvironments: newSettings.systemEnvironments !== undefined
+                    ? newSettings.systemEnvironments
+                    : this.settings.systemEnvironments, // Keep existing if not in newSettings
+                userConfigurations: newSettings.userConfigurations !== undefined
+                    ? newSettings.userConfigurations
+                    : this.settings.userConfigurations || {}, // Keep existing or default to empty
+            };
+            this.settings = updatedSettings;
+            // Call the internal, non-locking version of applyDefaultsIfNeeded
+            await this._applyDefaultsIfNeededInternal();
+            // _applyDefaultsIfNeededInternal will call _saveSettingsInternal if it makes changes.
+            // However, if newSettings were provided that didn't trigger a change in _applyDefaultsIfNeededInternal
+            // (e.g., just updating an existing path), we still need to save.
+            // So, always call _saveSettingsInternal to persist all merged changes.
+            await this._saveSettingsInternal();
+            Logger.info('System settings updated.');
+            // getSystemSettings will handle its own locking if it needs to load.
+            return this.getSystemSettings();
+        });
+    }
+    /**
+     * Internal method to save settings to the file without acquiring a lock.
+     * Assumes the lock is already held by the calling public method.
+     * Normalizes paths before saving.
+     * @returns A promise that resolves when settings are written to disk.
+     */
+    async _saveSettingsInternal() {
+        try {
+            // Normalize paths before saving
+            const settingsToSave = { ...this.settings };
+            settingsToSave.nodePath = settingsToSave.nodePath?.replace(/\\/g, '/');
+            settingsToSave.browserPath = settingsToSave.browserPath?.replace(/\\/g, '/');
+            if (settingsToSave.pythonEnvs) {
+                const normalizedPythonEnvs = {};
+                Object.keys(settingsToSave.pythonEnvs).forEach(key => {
+                    normalizedPythonEnvs[key] = settingsToSave.pythonEnvs?.[key]?.replace(/\\/g, '/') || '';
+                });
+                settingsToSave.pythonEnvs = normalizedPythonEnvs;
+            }
+            await fs.mkdir(path.dirname(this.settingsFilePath), { recursive: true });
+            await fs.writeFile(this.settingsFilePath, JSON.stringify(settingsToSave, null, 2));
+            Logger.info(`System settings saved to ${this.settingsFilePath}`);
+        }
+        catch (error) {
+            Logger.error(`Error saving settings to ${this.settingsFilePath}:`, error);
+            throw error; // Re-throw to indicate failure
+        }
+    }
+    /**
+     * Saves the current settings to the file. This operation is atomic and protected by a lock.
+     * Paths are normalized before saving.
+     * @returns A promise that resolves when the settings are saved.
+     */
+    async saveSettings() {
+        await this.withLock(async () => {
+            await this._saveSettingsInternal();
+        });
+    }
+}
+export const systemSettingsManager = SystemSettingsManager.getInstance();
+//# sourceMappingURL=SystemSettingsManager.js.map

package/dist/core/metadatas/constants.d.ts

@@ -18,6 +18,13 @@ export declare const SETTINGS_DIR: string;
  * Local feeds directory path
  */
 export declare const LOCAL_FEEDS_DIR: string;
+/**
+ * Path to the user information file
+ */
+export declare const USER_INFO_PATH: string;
+/**
+ * Path to the local feeds schema directory
+ */
 export declare const LOCAL_FEEDS_SCHEMA_DIR: string;
 /**
  * Supported client configurations.

package/dist/core/metadatas/constants.js

@@ -27,6 +27,13 @@ export const SETTINGS_DIR = (() => {
  * Local feeds directory path
  */
 export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
+/**
+ * Path to the user information file
+ */
+export const USER_INFO_PATH = path.join(SETTINGS_DIR, 'settings', 'user_info.json');
+/**
+ * Path to the local feeds schema directory
+ */
 export const LOCAL_FEEDS_SCHEMA_DIR = path.join(LOCAL_FEEDS_DIR, 'schemas');
 const CODE_STRORAGE_DIR = (() => {
     switch (process.platform) {

package/dist/core/metadatas/recordingConstants.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 declare const STEP_PROCESS_REQUIREMENT_UPDATES = "Processing all requirement updates";
+/** Step for checking the status of a specific requirement. */
+export declare const STEP_CHECKING_REQUIREMENT_STATUS = "Checking the status of requirement";
+/** Step for installing requirements in the background process. */
+export declare const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = "Installing requirements in the background";
+/** Step for checking and installing all requirements as needed. */
+export declare const STEP_CHECK_AND_INSTALL_REQUIREMENTS = "Checking and installing all requirements";
+/** Step for running the install logic in the CommandInstaller. */
+export declare const STEP_COMMAND_INSTALLER_INSTALL = "Running install in CommandInstaller";
+/** Step for running the install logic in the GeneralInstaller. */
+export declare const STEP_GENERAL_INSTALLER_INSTALL = "Running install in GeneralInstaller";
+/** Step for executing the actual installation command (npm, pip, etc.). */
+export declare const STEP_INSTALLATION_COMMAND_EXECUTION = "Executing installation command for requirement";
+/** Step for running the install logic in the PipInstaller. */
+export declare const STEP_PIP_INSTALLER_INSTALL = "Running install in PipInstaller";
+/** Step for processing requirement updates in the RequirementService. */
+export declare const STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE = "Processing requirement updates in RequirementService";
+/** Step for checking if the server is ready after installation. */
+export declare const STEP_CHECK_SERVER_READINESS = "Checking server readiness after installation";
+/** Step for running the install logic in the NpmInstaller. */
+export declare const STEP_NPM_INSTALLER_INSTALL = "Running install in NpmInstaller";
+/** Prefix for steps that update a specific requirement. */
+export declare const STEP_INSTALL_REQUIREMENT_PREFIX = "Updating requirement:";
+/** Prefix for steps that execute an installation command for a requirement. */
+export declare const STEP_INSTALL_COMMAND_PREFIX = "Executing installation command for:";
+/** Step for checking and installing the VS Code extension for the client. */
+export declare 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 declare const STEP_SETUP_INSTALLATION_CONFIG = "Setting up installation configuration";
+/** Step for updating VS Code settings for the client/server. */
+export declare const STEP_UPDATE_VSCODE_SETTINGS = "Updating VS Code settings for client/server";
+/** Step for the overall installation process of a client or server. */
+export declare const STEP_INSTALLATION = "Running overall installation process";
+/** Step for marking the initiation of an onboarding or installation process. */
+export declare const STEP_INITIATED = "Initiating onboarding or installation process";

package/dist/core/metadatas/recordingConstants.js

@@ -0,0 +1,45 @@
+/**
+ * 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';
+//# sourceMappingURL=recordingConstants.js.map

package/dist/core/metadatas/types.d.ts

@@ -165,3 +165,24 @@ export interface MCPEventData {
         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/dist/core/onboard/FeedOnboardService.d.ts

@@ -13,16 +13,20 @@ export declare class FeedOnboardService {
      */
     private createOperationId;
     /**
-     * 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
      */
     onboardFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
         feedConfiguration?: FeedConfiguration;
     }>;
     /**
-     * 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
      */
     validateFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
         feedConfiguration?: FeedConfiguration;

package/dist/core/onboard/FeedOnboardService.js

@@ -1,7 +1,7 @@
 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 } from './OnboardStatus.js';
 import { onboardStatusManager } from './OnboardStatusManager.js';
 import { onboardProcessor } from './OnboardProcessor.js';
@@ -23,8 +23,10 @@ export class FeedOnboardService {
         return `${feedName}_${operationType}`;
     }
     /**
-     * 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
      */
     async onboardFeed(config, forExistingCategory) {
         // Perform static validation first
@@ -40,10 +42,19 @@ 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
             };
@@ -58,9 +69,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
      */
     async validateFeed(config, forExistingCategory) {
         // Perform static validation first
@@ -307,10 +320,28 @@ 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
+            });
         }
     }
     /**
@@ -359,6 +390,14 @@ export class FeedOnboardService {
                 await configProvider.initialize(feedFilePath, { prLink: prInfo.url, adhocServers: serverList }); // configProvider is already an instance
                 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}:`);
@@ -368,6 +407,14 @@ export class FeedOnboardService {
         catch (error) {
             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/dist/core/onboard/InstallOperationManager.d.ts

@@ -0,0 +1,23 @@
+import { InstallOperationDetails } from '../metadatas/types.js';
+export declare class InstallOperationManager {
+    private static instance;
+    private installOperationStatus;
+    private statusLock;
+    private constructor();
+    static getInstance(): InstallOperationManager;
+    private withLock;
+    private loadStatuses;
+    private saveStatuses;
+    private createOperationKey;
+    recordStep(categoryName: string, serverName: string, stepName: string, isSucceeded: boolean, message?: string): Promise<InstallOperationDetails>;
+    /**
+     * Resets (deletes) the operation status for a given category and server.
+     * This is useful to call before starting a new installation attempt.
+     * @param categoryName The name of the category.
+     * @param serverName The name of the server.
+     */
+    resetOperation(categoryName: string, serverName: string): Promise<void>;
+    getDetails(categoryName: string, serverName: string): Promise<InstallOperationDetails | undefined>;
+    getAllDetails(): Promise<Record<string, InstallOperationDetails>>;
+}
+export declare const installOperationManager: InstallOperationManager;