imcp 0.1.1 → 0.1.3

package/src/core/installers/clients/ClientInstaller.ts

@@ -9,6 +9,8 @@ import {
 } from '../../metadatas/types.js';
 import { Logger } from '../../../utils/logger.js';
 import { ClientInstallerFactory } from './ClientInstallerFactory.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import { stat } from 'fs';
 
 /**
  * Main client installer class that orchestrates client installation process
@@ -26,56 +28,27 @@ export class ClientInstaller {
     }
 
     /**
-     * Generate a unique operation ID for tracking installations
-     */
-    private generateOperationId(): string {
-        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-
-    /**
-     * Check if server requirements are ready
-     * Waits for requirements to be ready with timeout
+     * Install all specified clients
      */
-    private async checkRequirements(operationId: string, clientName: string, options: ServerInstallOptions): Promise<boolean> {
-        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
-
-        if (!requirementsReady) {
-            const pendingStatus: OperationStatus = {
-                status: 'pending',
-                type: 'install',
-                target: 'server',
-                message: `Waiting for requirements to be ready for client: ${clientName}`,
-                operationId
-            };
-
-            await this.configProvider.updateServerOperationStatus(
-                this.categoryName,
-                this.serverName,
-                clientName,
-                pendingStatus
-            );
-
-            // Set up periodic checking with timeout
-            const startTime = Date.now();
-            const timeoutMs = 5 * 60 * 1000; // 5 minutes
-            const intervalMs = 5 * 1000; // 5 seconds
-
-            while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
-                await new Promise(resolve => setTimeout(resolve, intervalMs));
-                requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
-            }
-        }
+    async install(options: ServerInstallOptions): Promise<ServerOperationResult> {
+        const initialStatuses: OperationStatus[] = [];
 
-        var requirementsStatus: RequirementStatus[] = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
+        // Start installation for each client asynchronously
+        const installPromises = this.clients.map(async (clientName) => {
+            const status = await this.installClient(clientName, options);
+            initialStatuses.push(status);
+            return status;
+        });
 
-        // Find first non-empty npmPath from requirements status
-        const npmPathRequirement = requirementsStatus.find(status => status.npmPath && status.npmPath.length > 0);
-        if (npmPathRequirement && npmPathRequirement.npmPath) {
-            options.settings = options.settings || {};
-            options.settings.npmPath = npmPathRequirement.npmPath;
-        }
+        // Wait for all installations to complete
+        await Promise.all(installPromises);
 
-        return requirementsReady;
+        // Return result
+        return {
+            success: true,
+            message: 'Client installations completed',
+            status: initialStatuses
+        };
     }
 
     /**
@@ -104,7 +77,41 @@ export class ClientInstaller {
             operationId
         };
 
-        this.processInstallation(clientName, operationId, options);
+        // Async installation process
+        this.processInstallation(clientName, operationId, options)
+            .then((status) => {
+                if (status.status === 'completed' || status.status === 'failed') {
+                    InstallOperationManager
+                        .getInstance(this.categoryName, this.serverName)
+                        .markOverallStatus(status.status)
+                }
+
+                this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    status
+                );
+            })
+            .catch((error) => {
+                this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    {
+                        status: 'failed',
+                        type: 'install',
+                        target: 'server',
+                        message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`,
+                        operationId,
+                        error: error instanceof Error ? error.message : String(error)
+                    }
+                );
+                Logger.error(`Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`);
+                InstallOperationManager
+                    .getInstance(this.categoryName, this.serverName)
+                    .markOverallStatus('failed', error)
+            });
 
         // Update server status with initial client installation status
         await this.configProvider.updateServerOperationStatus(
@@ -116,107 +123,100 @@ export class ClientInstaller {
         return initialStatus;
     }
 
-    private async processInstallation(clientName: string, operationId: string, options: ServerInstallOptions): Promise<void> {
-        try {
-            // Check requirements
-            const requirementsReady = await this.checkRequirements(operationId, clientName, options);
-            if (!requirementsReady) {
-                const failedStatus: OperationStatus = {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: `Requirements not ready for client: ${clientName} after timeout`,
-                    operationId
-                };
-
-                await this.configProvider.updateServerOperationStatus(
-                    this.categoryName,
-                    this.serverName,
-                    clientName,
-                    failedStatus
-                );
-                return;
-            }
+    private async processInstallation(clientName: string, operationId: string, options: ServerInstallOptions): Promise<OperationStatus> {
+        const requirementsReady = await this.checkRequirements(operationId, clientName, options);
+        if (!requirementsReady) {
+            const failedStatus: OperationStatus = {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Requirements not ready for client: ${clientName} after timeout`,
+                operationId
+            };
+            return failedStatus;
+        }
 
-            // Create client-specific installer
-            const installer = ClientInstallerFactory.getInstaller(clientName);
+        // Create client-specific installer
+        const installer = ClientInstallerFactory.getInstaller(clientName);
 
-            if (!installer) {
-                throw new Error(`Failed to create installer for client: ${clientName}`);
-            }
+        if (!installer) {
+            throw new Error(`Failed to create installer for client: ${clientName}`);
+        }
 
-            const serverConfig = await this.configProvider.getServerMcpConfig(this.categoryName, this.serverName);
-            if (!serverConfig) {
-                throw new Error(`Server configuration not found for category: ${this.categoryName}, server: ${this.serverName}`);
-            }
+        const serverConfig = await this.configProvider.getServerMcpConfig(this.categoryName, this.serverName);
+        if (!serverConfig) {
+            throw new Error(`Server configuration not found for category: ${this.categoryName}, server: ${this.serverName}`);
+        }
 
-            // If we've reached here, requirements are ready - update status to in-progress
-            const inProgressStatus: OperationStatus = {
-                status: 'in-progress',
-                type: 'install',
-                target: 'server',
-                message: `Installing client: ${clientName}`,
-                operationId: operationId
-            };
+        // If we've reached here, requirements are ready - update status to in-progress
+        const inProgressStatus: OperationStatus = {
+            status: 'in-progress',
+            type: 'install',
+            target: 'server',
+            message: `Installing client: ${clientName}`,
+            operationId: operationId
+        };
 
-            await this.configProvider.updateServerOperationStatus(
-                this.categoryName,
-                this.serverName,
-                clientName,
-                inProgressStatus
-            );
-            // Install client
-            const status = await installer.install(serverConfig, options);
-            await this.configProvider.updateServerOperationStatus(
-                this.categoryName,
-                this.serverName,
-                clientName,
-                status
-            );
+        await this.configProvider.updateServerOperationStatus(
+            this.categoryName,
+            this.serverName,
+            clientName,
+            inProgressStatus
+        );
+        // Install client
+        return await installer.install(serverConfig, options, this.categoryName);
+    }
 
-            if (status.status === 'completed') {
-                await this.configProvider.reloadClientMCPSettings();
-            }
-        } catch (error) {
-            const errorStatus: OperationStatus = {
-                status: 'failed',
+    /**
+ * Generate a unique operation ID for tracking installations
+ */
+    private generateOperationId(): string {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Check if server requirements are ready
+     * Waits for requirements to be ready with timeout
+     */
+    private async checkRequirements(operationId: string, clientName: string, options: ServerInstallOptions): Promise<boolean> {
+        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+
+        if (!requirementsReady) {
+            const pendingStatus: OperationStatus = {
+                status: 'pending',
                 type: 'install',
                 target: 'server',
-                message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`,
-                operationId,
-                error: error instanceof Error ? error.message : String(error)
+                message: `Waiting for requirements to be ready for client: ${clientName}`,
+                operationId
             };
 
             await this.configProvider.updateServerOperationStatus(
                 this.categoryName,
                 this.serverName,
                 clientName,
-                errorStatus
+                pendingStatus
             );
-        }
-    }
 
-    /**
-     * Install all specified clients
-     */
-    async install(options: ServerInstallOptions): Promise<ServerOperationResult> {
-        const initialStatuses: OperationStatus[] = [];
+            // Set up periodic checking with timeout
+            const startTime = Date.now();
+            const timeoutMs = 5 * 60 * 1000; // 5 minutes
+            const intervalMs = 5 * 1000; // 5 seconds
 
-        // Start installation for each client asynchronously
-        const installPromises = this.clients.map(async (clientName) => {
-            const status = await this.installClient(clientName, options);
-            initialStatuses.push(status);
-            return status;
-        });
+            while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
+                await new Promise(resolve => setTimeout(resolve, intervalMs));
+                requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+            }
+        }
 
-        // Wait for all installations to complete
-        await Promise.all(installPromises);
+        var requirementsStatus: RequirementStatus[] = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
 
-        // Return result
-        return {
-            success: true,
-            message: 'Client installations completed',
-            status: initialStatuses
-        };
+        // Find first non-empty npmPath from requirements status
+        const npmPathRequirement = requirementsStatus.find(status => status.npmPath && status.npmPath.length > 0);
+        if (npmPathRequirement && npmPathRequirement.npmPath) {
+            options.settings = options.settings || {};
+            options.settings.npmPath = npmPathRequirement.npmPath;
+        }
+
+        return requirementsReady;
     }
 }

package/src/core/installers/requirements/BaseInstaller.ts

@@ -3,6 +3,7 @@ import path from 'path';
 import { SETTINGS_DIR } from '../../metadatas/constants.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 import { Logger } from '../../../utils/logger.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 
 /**
  * Abstract base class with common functionality for all requirement installers
@@ -18,7 +19,14 @@ export abstract class BaseInstaller implements RequirementInstaller {
 
     abstract canHandle(requirement: RequirementConfig): boolean;
     abstract supportCheckUpdates(): boolean;
-    abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Install the requirement
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation
+     */
+    abstract install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus>;
     abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Get the latest version available for the requirement.

package/src/core/installers/requirements/CommandInstaller.ts

@@ -2,6 +2,8 @@ import { RequirementConfig, RequirementStatus, OSType, ServerInstallOptions } fr
 import { BaseInstaller } from './BaseInstaller.js';
 import { getOSType, refreshPathEnv } from '../../../utils/osUtils.js';
 import { Logger } from '../../../utils/logger.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
 
 /**
  * Mapping of command names to their package IDs on different platforms
@@ -138,8 +140,15 @@ export class CommandInstaller extends BaseInstaller {
      * @param requirement The requirement to install
      * @returns The status of the installation
      */
-    async install(requirement: RequirementConfig): Promise<RequirementStatus> {
-        try {
+    /**
+     * Install the command
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation
+     */
+    async install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        const doInstall = async (): Promise<RequirementStatus> => {
             const status = await this.checkInstallation(requirement);
             if (status.installed) {
                 return status;
@@ -150,18 +159,17 @@ export class CommandInstaller extends BaseInstaller {
             let installCommand: string;
 
             if (osType === OSType.Windows) {
-                // Windows installation using winget
                 installCommand = `winget install --id ${packageId}`;
                 if (requirement.version && requirement.version !== 'latest') {
                     installCommand += ` --version ${requirement.version}`;
                 }
             } else if (osType === OSType.MacOS) {
-                // macOS installation using Homebrew
                 installCommand = `brew install ${packageId}`;
                 if (requirement.version && requirement.version !== 'latest') {
                     installCommand += `@${requirement.version}`;
                 }
             } else {
+                if (recorder) await recorder.recordStep('CommandInstaller:UnsupportedOS', 'failed', `Unsupported OS for ${requirement.name}`);
                 throw new Error(`Unsupported operating system for installing ${requirement.name}`);
             }
 
@@ -176,7 +184,6 @@ export class CommandInstaller extends BaseInstaller {
             if (!updatedStatus.installed) {
                 throw new Error(`Failed to install ${requirement.name}`);
             }
-
             return {
                 name: requirement.name,
                 type: 'command',
@@ -184,14 +191,41 @@ export class CommandInstaller extends BaseInstaller {
                 version: updatedStatus.version || requirement.version,
                 inProgress: false
             };
-        } catch (error) {
-            return {
-                name: requirement.name,
-                type: 'command',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
+        };
+
+        if (recorder) {
+            return recorder.recording(doInstall, {
+                stepName: RecordingConstants.STEP_COMMAND_INSTALLER_INSTALL,
+                inProgressMessage: `Installing command: ${requirement.name}`,
+                endMessage: (result) =>
+                    result.installed
+                        ? `Install completed for ${requirement.name}`
+                        : `Install failed for ${requirement.name}`,
+                onError: (error) => {
+                    return {
+                        result: {
+                            name: requirement.name,
+                            type: 'command',
+                            installed: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            inProgress: false,
+                        },
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                },
+            });
+        } else {
+            try {
+                return await doInstall();
+            } catch (error) {
+                return {
+                    name: requirement.name,
+                    type: 'command',
+                    installed: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    inProgress: false,
+                };
+            }
         }
     }
 }

package/src/core/installers/requirements/GeneralInstaller.ts

@@ -2,6 +2,8 @@ import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../.
 import { BaseInstaller } from './BaseInstaller.js';
 import { handleGitHubRelease } from '../../../utils/githubUtils.js';
 import { handleArtifact } from '../../../utils/adoUtils.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
 
 /**
  * Installer implementation for general requirements (type 'other')
@@ -55,8 +57,17 @@ export class GeneralInstaller extends BaseInstaller {
      * @param requirement The requirement to install
      * @returns The status of the installation, including the install path in updateInfo
      */
-    async install(requirement: RequirementConfig): Promise<RequirementStatus> {
-        try {
+    /**
+     * Install the general requirement
+     * For type 'other', this doesn't actually install anything, but downloads
+     * or locates the asset and returns the path for the caller to use
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation, including the install path in updateInfo
+     */
+    async install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        const doInstall = async (): Promise<RequirementStatus> => {
             // For type 'other', a registry must be specified
             if (!requirement.registry) {
                 throw new Error('Registry must be specified for requirement type "other"');
@@ -82,14 +93,41 @@ export class GeneralInstaller extends BaseInstaller {
                 version: requirement.version,
                 inProgress: false,
             };
-        } catch (error) {
-            return {
-                name: requirement.name,
-                type: 'other',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
+        };
+
+        if (recorder) {
+            return recorder.recording(doInstall, {
+                stepName: RecordingConstants.STEP_GENERAL_INSTALLER_INSTALL,
+                inProgressMessage: `Installing general requirement: ${requirement.name}`,
+                endMessage: (result) =>
+                    result.installed
+                        ? `Install completed for ${requirement.name}`
+                        : `Install failed for ${requirement.name}`,
+                onError: (error) => {
+                    return {
+                        result: {
+                            name: requirement.name,
+                            type: 'other',
+                            installed: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            inProgress: false,
+                        },
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                },
+            });
+        } else {
+            try {
+                return await doInstall();
+            } catch (error) {
+                return {
+                    name: requirement.name,
+                    type: 'other',
+                    installed: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    inProgress: false,
+                };
+            }
         }
     }
 }

package/src/core/installers/requirements/InstallerFactory.ts

@@ -6,7 +6,7 @@ import { CommandInstaller } from './CommandInstaller.js';
 import { GeneralInstaller } from './GeneralInstaller.js';
 import { exec } from 'child_process';
 import util from 'util';
-
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 /**
  * Factory for creating the appropriate installer for a requirement
  */
@@ -59,10 +59,11 @@ export class InstallerFactory {
     /**
      * Install a requirement using the appropriate installer
      * @param requirement The requirement to install
+     * @param recorder Optional InstallOperationManager for recording steps
      * @param options Installation options including python environment
      * @returns The installation status
      */
-    public async install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
+    public async install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
         const installer = this.getInstaller(requirement);
         if (!installer) {
             return {
@@ -74,7 +75,7 @@ export class InstallerFactory {
             };
         }
 
-        return await installer.install(requirement, options);
+        return await installer.install(requirement, recorder, options);
     }
 
     /**