imcp 0.1.6 → 0.1.8-dev

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

@@ -1,133 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,271 +0,0 @@
-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),
-                    };
-                },
-            });
-    }
-}