imcp 0.1.4 → 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/NugetInstaller.ts

@@ -1,203 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
-import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.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';
-import { ensureDotnetToolsInPath } from '../../../utils/osUtils.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * Installer implementation for .NET packages using NuGet
- */
-export class NugetInstaller 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 === 'nuget';
-    }
-
-    supportCheckUpdates(): boolean {
-        return true;
-    }
-
-    /**
-     * Get the latest version available for the NuGet package.
-     * @param requirement The requirement to check.
-     * @param _options Optional server install options (not used for NuGet).
-     * @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 && requirement.registry.githubRelease) {
-            return getGitHubLatestVersion(this.execPromise, requirement.registry.githubRelease.repository);
-        }
-        // Artifacts registry is not supported for nuget tools
-        if (requirement.registry && requirement.registry.artifacts) {
-            Logger.warn(`Artifacts registry is not supported for NuGet tool '${requirement.name}'.`);
-            return undefined;
-        }
-        // Default behavior: Nuget tools are often specific versions from specific sources,
-        // or global tools might not have a central "latest version" query like pip/npm.
-        // Returning current version if specified, otherwise undefined.
-        Logger.warn(`Direct latest version check for NuGet tool '${requirement.name}' without a GitHub release registry is not supported. Please specify a version or use a GitHub release.`);
-        return requirement.version || undefined;
-    }
-
-    /**
-     * Check if the .NET tool is already installed
-     * @param requirement The requirement to check
-     * @param _options Optional server install options (not used for NuGet)
-     * @returns The status of the requirement
-     */
-    async checkInstallation(requirement: RequirementConfig, _options?: ServerInstallOptions): Promise<RequirementStatus> {
-        try {
-            // Command: dotnet tool list -g
-            // Output:
-            // Package Id       Version      Commands
-            // -----------------------------------------
-            // jarvistools      1.0.0        jarvistools
-            const { stdout } = await this.execPromise(`dotnet tool list -g`);
-            const lines = stdout.split('\n');
-            let installedVersion: string | undefined;
-            let isInstalled = false;
-
-            for (const line of lines) {
-                const parts = line.trim().split(/\s+/);
-                if (parts.length >= 2 && parts[0].toLowerCase() === requirement.name.toLowerCase()) {
-                    installedVersion = parts[1];
-                    isInstalled = true;
-                    break;
-                }
-            }
-
-            return {
-                name: requirement.name,
-                type: 'nuget',
-                installed: isInstalled,
-                version: installedVersion,
-                inProgress: false,
-            };
-        } catch (error) {
-            // If 'dotnet tool list -g' fails, it might mean dotnet CLI is not properly installed or configured.
-            // Or it could mean no tools are installed, which in some dotnet versions might return non-zero exit code.
-            // We'll assume not installed in case of error, but log it.
-            Logger.debug(`Error checking NuGet tool installation for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                name: requirement.name,
-                type: 'nuget',
-                installed: false,
-                error: `Failed to check installation: ${error instanceof Error ? error.message : String(error)}`,
-                inProgress: false,
-            };
-        }
-    }
-
-    /**
-     * Install the .NET tool
-     * @param requirement The requirement to install
-     * @param recorder Optional InstallOperationManager for recording steps
-     * @param _options Optional server install options (not used for NuGet)
-     * @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 && requirement.version &&
-                    compareVersions(status.version, requirement.version) === 0 &&
-                    !requirement.version.toLowerCase().includes('latest')) {
-                    Logger.log(`NuGet tool ${requirement.name}==${status.version} already installed.`);
-                    return status;
-                }
-
-                let command: string;
-
-                if (requirement.registry && requirement.registry.githubRelease) {
-                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                    // Nuget package name might be different from the requirement name if alias is used.
-                    // However, dotnet tool install uses the package ID from the nupkg.
-                    // We assume requirement.name is the package ID.
-                    const packageId = requirement.name;
-                    const resolvedDir = fs.existsSync(result.resolvedPath) && fs.lstatSync(result.resolvedPath).isDirectory() ? result.resolvedPath : path.dirname(result.resolvedPath);
-
-                    if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
-                        command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId} --version ${requirement.version}`;
-                    } else {
-                        // Install latest from the source
-                        command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId}`;
-                    }
-                } else if (requirement.registry && requirement.registry.artifacts) {
-                    const errorMessage = `Artifacts registry is not supported for NuGet tool yet'${requirement.name}'. Only GitHubRelease is supported.`;
-                    Logger.error(errorMessage);
-                    await recorder.recordStep('NugetInstaller:RegistryConfig', 'failed', errorMessage);
-                    throw new Error(errorMessage);
-                } else {
-                    // Default installation from nuget.org or configured feeds
-                    if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
-                        command = `dotnet tool install --global ${requirement.name} --version ${requirement.version}`;
-                    } else {
-                        command = `dotnet tool install --global ${requirement.name}`;
-                    }
-                }
-
-                return await recorder.recording(
-                    async () => {
-                        const { stdout, stderr } = await this.execPromise(command);
-                        if (stderr && !stdout.toLowerCase().includes('already installed')) { // Some warnings might go to stderr
-                            Logger.debug(`NuGet tool installation stderr for ${requirement.name}: ${stderr}`);
-                            // Check if it was actually an error or just a warning
-                            const checkStatus = await this.checkInstallation(requirement, _options);
-                            if (!checkStatus.installed) {
-                                Logger.error(`NuGet tool ${requirement.name} not found after install command, stderr: ${stderr}`);
-                                throw new Error(`NuGet tool installation failed with: ${stderr}`);
-                            }
-                        }
-
-                        const finalStatus = await this.checkInstallation(requirement, _options);
-                        if (!finalStatus.installed) {
-                             throw new Error(`NuGet tool ${requirement.name} failed to install. Please check logs.`);
-                        }
-                        // After successful installation, ensure .NET tools path is in system PATH
-                        await ensureDotnetToolsInPath();
-                        return {
-                            name: requirement.name,
-                            type: 'nuget',
-                            installed: true,
-                            version: finalStatus.version || requirement.version, // Use checked version if available
-                            inProgress: false,
-                        };
-                    },
-                    {
-                        stepName: `${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${requirement.name} : ${requirement.version || 'latest'}`,
-                        inProgressMessage: `Running: ${command}`,
-                        endMessage: (result) => result.installed ? `Succeeded: ${command}` : `Failed: ${command}`,
-                    }
-                );
-            },
-            {
-                stepName: RecordingConstants.STEP_NUGET_INSTALLER_INSTALL,
-                inProgressMessage: `Installing NuGet tool: ${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: 'nuget',
-                            installed: false,
-                            error: error instanceof Error ? error.message : String(error),
-                            inProgress: false,
-                        },
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                },
-            }
-        );
-    }
-}