imcp 0.0.19 → 0.1.2

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);
     }
 
     /**

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

@@ -8,6 +8,9 @@ import path from 'path';
 import fs from 'fs/promises';
 import { SETTINGS_DIR } from '../../metadatas/constants.js'; // Corrected path
 import { Logger } from '../../../utils/logger.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
+
 /**
  * Installer implementation for NPM packages
  */
@@ -152,7 +155,8 @@ export class NpmInstaller extends BaseInstaller {
     private async _installPackage(
         requirement: RequirementConfig,
         packageSource: string,
-        targetDir: string
+        targetDir: string,
+        recorder: InstallOperationManager
     ): Promise<{ version: string }> {
         Logger.debug(`Installing NPM package from "${packageSource}" into "${targetDir}"`);
         await fs.mkdir(targetDir, { recursive: true });
@@ -161,89 +165,107 @@ export class NpmInstaller extends BaseInstaller {
         Logger.debug(`Executing install command: ${installCommand}`);
         const requirementName = this._getRequirementName(requirement);
 
-        try {
-            const { stdout: installStdout, stderr: installStderr } = await this.execPromise(installCommand);
-            Logger.debug(`NPM install stdout for ${packageSource} in ${targetDir}: ${installStdout}`);
-            if (installStderr && !installStderr.toLowerCase().includes('added') && !installStderr.toLowerCase().includes('updated') && !installStderr.toLowerCase().includes('found 0 vulnerabilities')) {
-                // Log stderr if it's not just typical success noise
-                Logger.log(`NPM install stderr for ${packageSource} in ${targetDir}: ${installStderr}`);
-            }
+        return await recorder.recording(
+            async () => {
+                const { stdout: installStdout, stderr: installStderr } = await this.execPromise(installCommand);
+                Logger.debug(`NPM install stdout for ${packageSource} in ${targetDir}: ${installStdout}`);
+                if (installStderr && !installStderr.toLowerCase().includes('added') && !installStderr.toLowerCase().includes('updated') && !installStderr.toLowerCase().includes('found 0 vulnerabilities')) {
+                    // Log stderr if it's not just typical success noise
+                    Logger.log(`NPM install stderr for ${packageSource} in ${targetDir}: ${installStderr}`);
+                }
 
 
-            const installedVersion = await this._getInstalledVersion(requirementName, targetDir);
+                const installedVersion = await this._getInstalledVersion(requirementName, targetDir);
 
-            if (installedVersion) {
-                Logger.log(`Successfully installed and verified ${requirementName}@${installedVersion} into ${targetDir}`);
-                return { version: installedVersion };
-            } else {
-                throw new Error(`Successfully ran npm install for ${packageSource}, but ${requirement.name} version could not be determined via npm list in ${targetDir}.`);
+                if (installedVersion) {
+                    Logger.log(`Successfully installed and verified ${requirementName}@${installedVersion} into ${targetDir}`);
+                    return { version: installedVersion };
+                } else {
+                    throw new Error(`Successfully ran npm install for ${packageSource}, but ${requirement.name} version could not be determined via npm list in ${targetDir}, stderr: ${installStderr}`);
+                }
+            },
+            {
+                stepName: RecordingConstants.STEP_INSTALLATION_COMMAND_EXECUTION,
+                inProgressMessage: `Running: ${installCommand}`,
+                onError: (error) => {
+                    Logger.error(`Error during NPM installation: ${error instanceof Error ? error.message : String(error)}`);
+                    throw error;
+                }
             }
-
-        } catch (error) {
-            Logger.error(`Failed to install or verify NPM package ${packageSource} into ${targetDir}`, error);
-            throw error;
-        }
+        )
     }
 
-
     /**
      * Install the NPM package.
      * @param requirement The requirement to install.
-     * @param options Installation options, including pythonCommand for ADO (though not used by npm) and folderName.
+     * @param recorder Optional InstallOperationManager for recording steps.
+     * @param options Installation options.
      * @returns The status of the installation.
      */
-    async install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
+    async install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
         const targetDir = options?.settings?.folderName || this._getRequirementFolderPath(requirement);
         await fs.mkdir(targetDir, { recursive: true });
+        return recorder.recording(
+            async (): Promise<RequirementStatus> => {
+                const status = await this.checkInstallation(requirement, { settings: { folderName: targetDir } });
+                if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0 && !requirement.version.toLowerCase().includes('latest')) {
+                    Logger.log(`${requirement.name}@${status.version} already installed in ${targetDir}.`);
+                    return status;
+                }
 
-        try {
-            const status = await this.checkInstallation(requirement, { settings: { folderName: targetDir } });
-            if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0 && !requirement.version.toLowerCase().includes('latest')) {
-                Logger.log(`${requirement.name}@${status.version} already installed in ${targetDir}.`);
-                return status;
-            }
+                let resolvedVersion = requirement.version;
+                let packageToInstall: string = `${requirement.name}@${requirement.version}`;
 
-            let resolvedVersion = requirement.version;
-            let packageToInstall: string = `${requirement.name}@${requirement.version}`;
-
-            if (requirement.registry) {
-                if (requirement.registry.githubRelease) {
-                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                    packageToInstall = result.resolvedPath;
-                    resolvedVersion = result.resolvedVersion;
-                } else if (requirement.registry.artifacts) {
-                    const adoResult: AdoArtifactResult = await handleAdoArtifact(
-                        requirement,
-                        requirement.registry.artifacts,
-                        options?.settings?.pythonCommand,
-                        targetDir
-                    );
-                    packageToInstall = `${adoResult.package}@${adoResult.version}`;
-                    resolvedVersion = adoResult.version;
-                } else {
-                    throw new Error('Invalid registry configuration for npm.');
+                if (requirement.registry) {
+                    if (requirement.registry.githubRelease) {
+                        const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                        packageToInstall = result.resolvedPath;
+                        resolvedVersion = result.resolvedVersion;
+                    } else if (requirement.registry.artifacts) {
+                        const adoResult: AdoArtifactResult = await handleAdoArtifact(
+                            requirement,
+                            requirement.registry.artifacts,
+                            options?.settings?.pythonCommand,
+                            targetDir
+                        );
+                        packageToInstall = `${adoResult.package}@${adoResult.version}`;
+                        resolvedVersion = adoResult.version;
+                    } else {
+                        if (recorder) await recorder.recordStep('NpmInstaller:RegistryConfig', 'failed', 'Invalid registry configuration for npm.');
+                        throw new Error('Invalid registry configuration for npm.');
+                    }
                 }
-            }
-            const finalInstallResult = await this._installPackage(requirement, packageToInstall, targetDir);
-            resolvedVersion = finalInstallResult.version;
+                const finalInstallResult = await this._installPackage(requirement, packageToInstall, targetDir, recorder);
+                resolvedVersion = finalInstallResult.version;
 
-
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: true,
-                version: resolvedVersion,
-                inProgress: false,
-                npmPath: targetDir
-            };
-        } catch (error) {
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
-        }
+                return {
+                    name: requirement.name,
+                    type: 'npm',
+                    installed: true,
+                    version: resolvedVersion,
+                    inProgress: false,
+                    npmPath: targetDir
+                };
+            },
+            {
+                stepName: RecordingConstants.STEP_NPM_INSTALLER_INSTALL,
+                inProgressMessage: `Installing npm package: ${requirement.name}`,
+                endMessage: (result) =>
+                    result.installed
+                        ? `Install completed for ${requirement.name}`
+                        : `Install failed for ${requirement.name}`,
+                onError: (error) => {
+                    return {
+                        result: {
+                            name: requirement.name,
+                            type: 'npm',
+                            installed: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            inProgress: false
+                        },
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                },
+            });
     }
 }

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

@@ -1,11 +1,11 @@
 import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
-// Assuming getArtifactLatestVersion will be available in adoUtils.ts
 import { handleArtifact as handleAdoArtifact, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
 import { compareVersions } from '../../../utils/versionUtils.js';
 import { Logger } from '../../../utils/logger.js';
-
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
 /**
  * Installer implementation for Python packages using pip
  */
@@ -113,69 +113,95 @@ export class PipInstaller extends BaseInstaller {
     /**
      * Install the Python package
      * @param requirement The requirement to install
+     * @param recorder Optional InstallOperationManager for recording steps
      * @param options Optional server install options
      * @returns The status of the installation
      */
-    async install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
-        try {
-            const status = await this.checkInstallation(requirement, options);
-            if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0 && !requirement.version.toLowerCase().includes('latest')) {
-                Logger.log(`${requirement.name}==${status.version} already installed for ${this.getPythonCommand}.`);
-                return status;
-            }
-
-            const pipCmd = this.getPipCommand(options);
+    async install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
 
-            if (!requirement.registry) {
-                const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
-                if (stderr && stderr.toLowerCase().includes('error')) {
-                    throw new Error(stderr);
+        return await recorder.recording(
+            async (): Promise<RequirementStatus> => {
+                const status = await this.checkInstallation(requirement, options);
+                if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0 && !requirement.version.toLowerCase().includes('latest')) {
+                    Logger.log(`${requirement.name}==${status.version} already installed for ${this.getPythonCommand}.`);
+                    return status;
                 }
-            } else {
-                let packageSource: string;
 
-                if (requirement.registry.githubRelease) {
-                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                    packageSource = result.resolvedPath;
-                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
-                    }
-                } else if (requirement.registry.artifacts) {
-                    const pythonCmd = this.getPythonCommand(options);
-                    const adoArtifactResult = await handleAdoArtifact(requirement, requirement.registry.artifacts, pythonCmd);
+                const pipCmd = this.getPipCommand(options);
+                let command: string
 
-                    const { stderr } = await this.execPromise(
-                        `${pipCmd} install ${adoArtifactResult.package} --extra-index-url ${adoArtifactResult.registryUrl}`
-                    );
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        const checkStatus = await this.checkInstallation(requirement, options);
-                        if (!checkStatus.installed) {
-                            throw new Error(`Pip installation failed with: ${stderr}`);
-                        }
+                if (!requirement.registry) {
+                    if (requirement.version && !requirement.version.includes('latest')) {
+                        command = `${pipCmd} install ${requirement.name}==${requirement.version}`;
+                    } else {
+                        command = `${pipCmd} install --upgrade ${requirement.name}`;
                     }
                 } else {
-                    throw new Error('Invalid registry configuration');
+                    let packageSource: string;
+                    if (requirement.registry.githubRelease) {
+                        const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                        packageSource = result.resolvedPath;
+                        command = `${pipCmd} install "${packageSource}"`
+                    } else if (requirement.registry.artifacts) {
+                        const pythonCmd = this.getPythonCommand(options);
+                        const adoArtifactResult = await handleAdoArtifact(requirement, requirement.registry.artifacts, pythonCmd);
+
+                        command = `${pipCmd} install ${adoArtifactResult.package} --extra-index-url ${adoArtifactResult.registryUrl}`;
+                    } else {
+                        await recorder.recordStep('PipInstaller:RegistryConfig', 'failed', 'Invalid registry configuration');
+                        throw new Error('Invalid registry configuration');
+                    }
                 }
-            }
+                return await recorder.recording(
+                    async () => {
+                        const { stderr } = await this.execPromise(command);
+                        if (stderr && stderr.toLowerCase().includes('error')) {
+                            Logger.debug(`Pip installation error: ${stderr}`);
 
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: true,
-                version: requirement.version, // This might need to be updated to actual installed version
-                inProgress: false,
-                pythonEnv: this.getPythonCommand(options)
-            };
-        } catch (error) {
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false,
-                pythonEnv: this.getPythonCommand(options)
-            };
-        }
+                            // wait for 5 seconds as python pip would be little delayed
+                            await new Promise(resolve => setTimeout(resolve, 5000));
+                            const checkStatus = await this.checkInstallation(requirement, options);
+                            if (!checkStatus.installed) {
+                                Logger.error(`Package not found after the command, ${stderr}`);
+                                throw new Error(`Pip installation failed with: ${stderr}`);
+                            }
+                        }
+
+                        return {
+                            name: requirement.name,
+                            type: 'pip',
+                            installed: true,
+                            version: requirement.version, // This might need to be updated to actual installed version
+                            inProgress: false,
+                            pythonEnv: this.getPythonCommand(options)
+                        };
+                    },
+                    {
+                        stepName: `${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${requirement.name} : ${requirement.version}`,
+                        inProgressMessage: `Running: ${command}`,
+                        endMessage: (result) => result.installed ? `Succeeded: ${command}` : `Failed: ${command}`,
+                    }
+                );
+            },
+            {
+                stepName: RecordingConstants.STEP_PIP_INSTALLER_INSTALL,
+                inProgressMessage: `Installing pip package: ${requirement.name}`,
+                endMessage: (result) => result.installed
+                    ? `Install completed for ${requirement.name} with version ${result.version}`
+                    : `Install failed for ${requirement.name}`,
+                onError: (error) => {
+                    return {
+                        result: {
+                            name: requirement.name,
+                            type: 'pip',
+                            installed: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            inProgress: false,
+                            pythonEnv: this.getPythonCommand(options)
+                        },
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                },
+            });
     }
 }

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

@@ -1,4 +1,5 @@
 import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 
 /**
  * Interface for requirement installers.
@@ -12,15 +13,15 @@ export interface RequirementInstaller {
      */
     canHandle(requirement: RequirementConfig): boolean;
 
-
     supportCheckUpdates(): boolean;
-
     /**
      * 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
      */
-    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus>;
 
     /**
      * Check if the requirement is already installed