imcp 0.1.1 → 0.1.2

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/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;

package/dist/core/onboard/InstallOperationManager.js

@@ -0,0 +1,144 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SETTINGS_DIR } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+const INSTALL_STATUS_DIR = path.join(SETTINGS_DIR, 'install');
+const INSTALL_OPERATION_STATUS_FILE = path.join(INSTALL_STATUS_DIR, 'InstallOperationStatus.json');
+export class InstallOperationManager {
+    static instance;
+    installOperationStatus = {};
+    statusLock = Promise.resolve();
+    constructor() {
+        this.loadStatuses().catch(error => Logger.error('Failed to initialize InstallOperationManager:', error));
+    }
+    static getInstance() {
+        if (!InstallOperationManager.instance) {
+            InstallOperationManager.instance = new InstallOperationManager();
+        }
+        return InstallOperationManager.instance;
+    }
+    async withLock(operation) {
+        const current = this.statusLock;
+        let resolve;
+        this.statusLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async loadStatuses() {
+        await this.withLock(async () => {
+            try {
+                await fs.mkdir(INSTALL_STATUS_DIR, { recursive: true });
+                const data = await fs.readFile(INSTALL_OPERATION_STATUS_FILE, 'utf-8');
+                this.installOperationStatus = JSON.parse(data);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    this.installOperationStatus = {};
+                    await this.saveStatuses(); // Create the file if it doesn't exist
+                }
+                else {
+                    Logger.error('Failed to load install operation statuses:', error);
+                    this.installOperationStatus = {}; // Initialize with empty statuses in case of other errors
+                }
+            }
+        });
+    }
+    async saveStatuses() {
+        await fs.mkdir(INSTALL_STATUS_DIR, { recursive: true });
+        await fs.writeFile(INSTALL_OPERATION_STATUS_FILE, JSON.stringify(this.installOperationStatus, null, 2));
+    }
+    createOperationKey(categoryName, serverName) {
+        return `${categoryName}-${serverName}`;
+    }
+    async recordStep(categoryName, serverName, stepName, isSucceeded, message) {
+        return await this.withLock(async () => {
+            const operationKey = this.createOperationKey(categoryName, serverName);
+            let operationDetails = this.installOperationStatus[operationKey];
+            const newStep = {
+                name: stepName,
+                isSucceeded,
+                message,
+                timestamp: new Date().toISOString(),
+            };
+            if (!operationDetails) {
+                operationDetails = {
+                    currentStep: stepName,
+                    steps: [newStep],
+                    lastUpdated: new Date().toISOString(),
+                    error: !isSucceeded ? message : undefined,
+                    overallStatus: isSucceeded ? 'in-progress' : 'failed',
+                };
+            }
+            else {
+                operationDetails.steps.push(newStep);
+                operationDetails.currentStep = stepName;
+                operationDetails.lastUpdated = new Date().toISOString();
+                if (!isSucceeded) {
+                    operationDetails.overallStatus = 'failed';
+                    if (!operationDetails.error) { // Store the first error
+                        operationDetails.error = message;
+                    }
+                }
+                else {
+                    // If this step succeeded, check if all previous steps also succeeded.
+                    // If a previous step failed, the overall status remains 'failed'.
+                    // If all steps are successful so far, it's 'in-progress' unless it's a known completion step.
+                    if (operationDetails.overallStatus !== 'failed') {
+                        if (stepName.toLowerCase().includes('completed') || stepName.toLowerCase().includes('succeeded')) {
+                            // Check if this is a "final" success step
+                            const isFinalSuccess = operationDetails.steps.every(s => s.isSucceeded);
+                            operationDetails.overallStatus = isFinalSuccess ? 'completed' : 'in-progress';
+                            if (isFinalSuccess)
+                                operationDetails.error = undefined; // Clear error on final success
+                        }
+                        else {
+                            operationDetails.overallStatus = 'in-progress';
+                        }
+                    }
+                }
+            }
+            // Special handling for the "InstallCompleted" step or similar final step names
+            if (stepName === 'InstallCompleted') {
+                operationDetails.overallStatus = isSucceeded ? 'completed' : 'failed';
+                if (isSucceeded)
+                    operationDetails.error = undefined;
+            }
+            this.installOperationStatus[operationKey] = operationDetails;
+            await this.saveStatuses();
+            return operationDetails;
+        });
+    }
+    /**
+     * 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.
+     */
+    async resetOperation(categoryName, serverName) {
+        await this.withLock(async () => {
+            const operationKey = this.createOperationKey(categoryName, serverName);
+            if (this.installOperationStatus[operationKey]) {
+                delete this.installOperationStatus[operationKey];
+                Logger.info(`Reset installation operation status for ${operationKey}`);
+                await this.saveStatuses();
+            }
+        });
+    }
+    async getDetails(categoryName, serverName) {
+        await this.loadStatuses(); // Ensure latest statuses are loaded
+        const operationKey = this.createOperationKey(categoryName, serverName);
+        return this.installOperationStatus[operationKey];
+    }
+    async getAllDetails() {
+        await this.loadStatuses();
+        return this.installOperationStatus;
+    }
+}
+// Export singleton instance
+export const installOperationManager = InstallOperationManager.getInstance();
+//# sourceMappingURL=InstallOperationManager.js.map

package/dist/core/onboard/OnboardStatusManager.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { SETTINGS_DIR } from '../metadatas/constants.js';
 import { OnboardingProcessStatus } 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
@@ -267,7 +268,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/dist/core/validators/StdioServerValidator.js

@@ -6,6 +6,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);
 /**
  * Validates MCP server configurations for stdio mode
@@ -45,7 +46,7 @@ export class StdioServerValidator {
      * @param requirement The requirement config to validate and install
      * @returns true if requirement is successfully installed/validated
      */
-    async validateRequirement(requirement) {
+    async validateRequirement(requirement, recorder) {
         try {
             Logger.debug(`Validating/installing requirement: ${requirement.name}`);
             const installer = this.installerFactory.getInstaller(requirement);
@@ -55,7 +56,7 @@ export class StdioServerValidator {
                 throw new Error(msg);
             }
             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);
@@ -257,7 +258,7 @@ export class StdioServerValidator {
                         version: req.version,
                         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}`);
                     }

package/dist/services/InstallationService.d.ts

@@ -3,48 +3,13 @@ import { ServerInstallOptions, ServerOperationResult } from '../core/metadatas/t
  * Handles the actual installation process for an MCP server.
  */
 export declare class InstallationService {
-    private activeInstallations;
-    private installerFactory;
     constructor();
-    private generateOperationId;
     /**
-     * Installs a server based on the provided options and feed configuration.
+     * Installs a server based on the provided options.
+     * @param categoryName The category name of the server.
      * @param serverName The name of the server to install.
      * @param options The installation options.
      * @returns A result object indicating success or failure.
      */
     install(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult>;
-    /**
-     * Process requirement updates specified in serverInstallOptions
-     * All updates are processed in parallel for maximum efficiency
-     * @param categoryName The category name
-     * @param serverName The server name
-     * @param requirements The requirements to update
-     */
-    private processRequirementUpdates;
-    /**
-     * Checks and installs requirements for a server if needed
-     * @param categoryName The category name
-     * @param serverName The server name
-     * @param options The installation options
-     * @returns A failure result if requirements check fails, null if requirements are satisfied
-     */
-    private checkAndInstallRequirements;
-    /**
-     * Installs requirements in background without blocking the main thread
-     * Requirements with the same order are installed in parallel
-     */
-    private installRequirementsInBackground;
-    /**
-     * Helper to update requirement status for failure case
-     */
-    private updateRequirementFailureStatus;
-    /**
-     * Helper to update requirement status for in-progress case
-     */
-    private updateRequirementProgressStatus;
-    /**
-     * Helper to update requirement status for completion case
-     */
-    private updateRequirementCompletionStatus;
 }