imcp 0.1.5 → 0.1.6

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

@@ -0,0 +1,133 @@
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
+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')
+ * This installer handles requirements that don't fit into specific package manager categories
+ */
+export class GeneralInstaller extends BaseInstaller {
+
+    /**
+     * Constructor for the GeneralInstaller
+     * @param execPromise Function to execute commands
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined> {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Check if this installer can handle the given requirement type
+     * @param requirement The requirement to check
+     * @returns True if this installer can handle the requirement
+     */
+    canHandle(requirement: RequirementConfig): boolean {
+        return requirement.type === 'other';
+    }
+
+    supportCheckUpdates(): boolean {
+        return false;
+    }
+    /**
+     * Check if the requirement is already installed
+     * For general installers, we can't easily check if something is installed
+     * without specific knowledge of the requirement, so we always return false
+     * 
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
+        // For general installers, we can't easily check if something is installed
+        // So we'll always return not installed, and the actual installation will check
+        return {
+            name: requirement.name,
+            type: 'other',
+            installed: false,
+            inProgress: false
+        };
+    }
+
+    /**
+     * 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
+     * @returns The status of the installation, including the install path in updateInfo
+     */
+    /**
+     * 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"');
+            }
+
+            let installPath: string;
+
+            if (requirement.registry.githubRelease) {
+                const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                installPath = result.resolvedPath;
+            } else if (requirement.registry.artifacts) {
+                await handleArtifact(requirement, requirement.registry.artifacts);
+            } else {
+                throw new Error('Invalid registry configuration');
+            }
+
+            // For general installer, we just return the path to the downloaded/located file
+            // The actual installation mechanism would depend on the specific requirement
+            return {
+                name: requirement.name,
+                type: 'other',
+                installed: true,
+                version: requirement.version,
+                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

@@ -0,0 +1,114 @@
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
+import { RequirementInstaller } from './RequirementInstaller.js';
+import { NpmInstaller } from './NpmInstaller.js';
+import { PipInstaller } from './PipInstaller.js';
+import { NugetInstaller } from './NugetInstaller.js';
+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
+ */
+export class InstallerFactory {
+    private installers: RequirementInstaller[] = [];
+    private readonly execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>;
+
+    /**
+     * Create a new InstallerFactory
+     * @param execPromise Function to execute commands
+     */
+    constructor(execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>) {
+        this.execPromise = execPromise;
+        this.registerDefaultInstallers();
+    }
+
+    /**
+     * Register default installers for npm, pip, and general requirements
+     * @private
+     */
+    private registerDefaultInstallers(): void {
+        this.registerInstaller(new NpmInstaller(this.execPromise));
+        this.registerInstaller(new PipInstaller(this.execPromise));
+        this.registerInstaller(new NugetInstaller(this.execPromise));
+        this.registerInstaller(new CommandInstaller(this.execPromise));
+        this.registerInstaller(new GeneralInstaller(this.execPromise));
+    }
+
+    /**
+     * Register a custom installer
+     * @param installer The installer to register
+     */
+    public registerInstaller(installer: RequirementInstaller): void {
+        this.installers.push(installer);
+    }
+
+    /**
+     * Get the appropriate installer for a requirement
+     * @param requirement The requirement to get an installer for
+     * @returns The appropriate installer, or undefined if none found
+     */
+    public getInstaller(requirement: RequirementConfig): RequirementInstaller | undefined {
+        // Validate that if registry is empty, type must not be 'other'
+        if (!requirement.registry && requirement.type === 'other') {
+            throw new Error('Registry must be specified for requirement type "other"');
+        }
+
+        return this.installers.find(installer => installer.canHandle(requirement));
+    }
+
+    /**
+     * 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, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        const installer = this.getInstaller(requirement);
+        if (!installer) {
+            return {
+                name: requirement.name,
+                type: requirement.type,
+                installed: false,
+                error: `No installer found for requirement type '${requirement.type}'`,
+                inProgress: false
+            };
+        }
+
+        return await installer.install(requirement, recorder, options);
+    }
+
+    /**
+      * Check the installation status of a requirement
+      * @param requirement The requirement to check
+      * @param options Installation options including python environment
+      * @returns The installation status
+      */
+    public async checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        const installer = this.getInstaller(requirement);
+        if (!installer) {
+            return {
+                name: requirement.name,
+                type: requirement.type,
+                installed: false,
+                error: `No installer found for requirement type '${requirement.type}'`,
+                inProgress: false
+            };
+        }
+
+        return await installer.checkInstallation(requirement, options);
+    }
+}
+
+/**
+ * Create a new InstallerFactory with default settings
+ * @param execPromise Optional function to execute commands
+ * @returns A new InstallerFactory
+ */
+export const createInstallerFactory = (
+    execPromise = util.promisify(exec)
+): InstallerFactory => {
+    return new InstallerFactory(execPromise);
+};

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

@@ -0,0 +1,271 @@
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
+// Assuming getArtifactLatestVersion will be available in adoUtils.ts
+import { handleArtifact as handleAdoArtifact, AdoArtifactResult, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
+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
+ */
+export class NpmInstaller extends BaseInstaller {
+    /**
+     * Check if this installer can handle the given requirement type
+     * @param requirement The requirement to check
+     * @returns True if this installer can handle the requirement
+     */
+    canHandle(requirement: RequirementConfig): boolean {
+        return requirement.type === 'npm';
+    }
+
+    supportCheckUpdates(): boolean {
+        return true;
+    }
+
+    /**
+     * Get the latest version available for the NPM package.
+     * @param requirement The requirement to check.
+     * @param options Optional server install options.
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    async getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined> {
+        if (requirement.registry) {
+            if (requirement.registry.githubRelease) {
+                return getGitHubLatestVersion(this.execPromise, requirement.registry.githubRelease.repository);
+            } else if (requirement.registry.artifacts) {
+                // Assuming getArtifactLatestVersion exists and has a compatible signature
+                // This might need adjustment based on the actual implementation of getArtifactLatestVersion
+                const targetDir = options?.settings?.folderName || this._getRequirementFolderPath(requirement);
+                return getArtifactLatestVersion(requirement, requirement.registry.artifacts, options, targetDir);
+            }
+        }
+        // Default: get common latest version from npm registry
+        const { stdout } = await this.execPromise(`npm view ${requirement.name} version`);
+        return stdout.trim();
+    }
+
+    /**
+     * Generates a dedicated folder path for a requirement.
+     * @param requirement The requirement configuration.
+     * @returns The path to the requirement's dedicated folder.
+     * @private
+     */
+    private _getRequirementFolderPath(requirement: RequirementConfig): string {
+        return path.join(
+            SETTINGS_DIR,
+            'npm_requirements',
+            requirement.name,
+            requirement.version.includes('latest') ? 'latest' : requirement.version);
+    }
+
+    /**
+     * Check if the NPM package is already installed in its dedicated folder.
+     * @param requirement The requirement to check
+     * @param options Installation options, may contain folderName.
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        const requirementDir = options?.settings?.folderName || this._getRequirementFolderPath(requirement);
+        const requirementName = this._getRequirementName(requirement);
+        Logger.debug(`Checking installation for ${requirementName} in ${requirementDir}`);
+        try {
+            const installedVersion = await this._getInstalledVersion(requirementName, requirementDir);
+
+            if (installedVersion) {
+                return {
+                    name: requirement.name,
+                    type: 'npm',
+                    installed: true,
+                    version: installedVersion,
+                    npmPath: requirementDir,
+                    inProgress: false,
+                };
+            }
+            // If package not found in dependencies or version is missing
+            return {
+                name: requirement.name,
+                type: 'npm',
+                installed: false,
+                inProgress: false,
+                error: `Package ${requirement.name} not found or version missing in npm list output in ${requirementDir}.`,
+            };
+        } catch (error) {
+            // npm list command likely failed (e.g., package not installed, or requirementDir not an npm project)
+            Logger.debug(`Error checking installation for ${requirement.name} in ${requirementDir}: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                name: requirement.name,
+                type: 'npm',
+                installed: false,
+                inProgress: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+
+    /**
+     * Retrieves the installed version of an NPM package from a given directory.
+     * @param requirementName The name of the NPM package.
+     * @param directory The directory to check for the package.
+     * @returns The installed version string, or undefined if not found or an error occurs.
+     * @private
+     */
+    private async _getInstalledVersion(requirementName: string, directory: string): Promise<string | undefined> {
+        try {
+            const command = `npm list ${requirementName} --depth=0 --json --prefix "${directory}"`;
+            Logger.debug(`Getting installed version for ${requirementName} in ${directory} with command: ${command}`);
+            const { stdout } = await this.execPromise(command);
+            const listOutput = JSON.parse(stdout);
+
+            if (listOutput.dependencies && listOutput.dependencies[requirementName] && listOutput.dependencies[requirementName].version) {
+                return listOutput.dependencies[requirementName].version;
+            }
+            Logger.debug(`Package ${requirementName} not found in npm list output in ${directory}.`);
+            return undefined;
+        } catch (error) {
+            Logger.debug(`Error getting installed version for ${requirementName} in ${directory}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined; // Return undefined on error to indicate version couldn't be retrieved
+        }
+    }
+
+
+    /**
+     * Get the name of the requirement, including registry information if applicable.
+     * @param requirement The requirement configuration.
+     * @returns The formatted requirement name.
+     * @private
+     */
+    private _getRequirementName(requirement: RequirementConfig): string {
+        return requirement.registry?.artifacts?.registryName ? `@${requirement.registry.artifacts.registryName}/${requirement.name}` : requirement.name;
+    }
+
+
+    /**
+     * Installs an NPM package into a dedicated local folder.
+     * @param requirement The requirement to install.
+     * @param packageSource This can be name@version, path to tgz, or path to folder.
+     * @param targetDir Target directory for installation.
+     * @returns The installed version of the package.
+     */
+    private async _installPackage(
+        requirement: RequirementConfig,
+        packageSource: string,
+        targetDir: string,
+        recorder: InstallOperationManager
+    ): Promise<{ version: string }> {
+        Logger.debug(`Installing NPM package from "${packageSource}" into "${targetDir}"`);
+        await fs.mkdir(targetDir, { recursive: true });
+
+        const installCommand = `npm install ${packageSource} --prefix "${targetDir}"`;
+        Logger.debug(`Executing install command: ${installCommand}`);
+        const requirementName = this._getRequirementName(requirement);
+
+        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);
+
+                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;
+                }
+            }
+        )
+    }
+
+    /**
+     * Install the NPM package.
+     * @param requirement The requirement to install.
+     * @param recorder Optional InstallOperationManager for recording steps.
+     * @param options Installation options.
+     * @returns The status of the installation.
+     */
+    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;
+                }
+
+                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 {
+                        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, recorder);
+                resolvedVersion = finalInstallResult.version;
+
+                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),
+                    };
+                },
+            });
+    }
+}