imcp 0.1.3 → 0.1.5

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),
-                    };
-                },
-            });
-    }
-}

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

@@ -1,207 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
-import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
-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
- */
-export class PipInstaller extends BaseInstaller {
-    private getPythonCommand(options?: ServerInstallOptions): string {
-        return options?.settings?.pythonEnv as string || 'python';
-    }
-
-    private getPipCommand(options?: ServerInstallOptions): string {
-        const pythonCmd = this.getPythonCommand(options);
-        return `${pythonCmd} -m pip`;
-    }
-
-    /**
-     * 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 === 'pip';
-    }
-
-    supportCheckUpdates(): boolean {
-        return true;
-    }
-
-    /**
-     * Get the latest version available for the pip 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
-                return getArtifactLatestVersion(requirement, requirement.registry.artifacts, options);
-            }
-        }
-        // Default: get common latest version from pip index
-        const pipCmd = this.getPipCommand(options);
-        const { stdout } = await this.execPromise(`${pipCmd} index versions ${requirement.name} --pre=0`);
-        // Parse output to find the latest version. Example output:
-        // mypackage (1.0.0)
-        // Available versions: 1.0.0, 0.9.0
-        // LATEST:          1.0.0
-        // Or for some packages:
-        // mypackage
-        // VERSIONS: 1.0.0, 0.9.0
-        // Latest: 1.0.0
-        const latestMatch = stdout.match(/(?:LATEST|Latest):\s*([^\s]+)/);
-        if (latestMatch && latestMatch[1]) {
-            return latestMatch[1];
-        }
-        // Fallback if LATEST line is not found, try to get the first version from "Available versions" or "VERSIONS"
-        const versionsMatch = stdout.match(/(?:Available versions|VERSIONS):\s*([^\n]+)/);
-        if (versionsMatch && versionsMatch[1]) {
-            const versions = versionsMatch[1].split(',').map(v => v.trim());
-            if (versions.length > 0) {
-                // Assuming versions are listed in a somewhat reasonable order,
-                // or we might need more sophisticated version sorting here.
-                return versions[0];
-            }
-        }
-        return undefined; // Or throw an error if version cannot be determined
-    }
-
-    /**
-     * Check if the Python package is already installed
-     * @param requirement The requirement to check
-     * @param options Optional server install options
-     * @returns The status of the requirement
-     */
-    async checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
-        try {
-            const pipCmd = this.getPipCommand(options);
-            const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
-
-            const installed = stdout.includes(requirement.name.toLowerCase());
-            const versionMatch = stdout.match(/Version: (.+)/);
-            const installedVersion = versionMatch ? versionMatch[1] : undefined;
-
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: installed,
-                version: installedVersion,
-                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)
-            };
-        }
-    }
-
-    /**
-     * 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, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
-
-        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;
-                }
-
-                const pipCmd = this.getPipCommand(options);
-                let command: string
-
-                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 {
-                    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}`);
-
-                            // 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),
-                    };
-                },
-            });
-    }
-}