imcp 0.1.7 → 0.1.8-dev

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

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

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

@@ -1,42 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
-import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
-
-/**
- * Interface for requirement installers.
- * Implementations should handle specific requirement types.
- */
-export interface RequirementInstaller {
-    /**
-     * 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;
-
-    supportCheckUpdates(): boolean;
-    /**
-     * Install the requirement
-     * @param requirement The requirement to install
-     * @param options Optional install options
-     * @param recorder Optional InstallOperationManager for recording steps
-     * @returns The status of the installation
-     */
-    install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus>;
-
-    /**
-     * Check if the requirement is already installed
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-
-    /**
-     * Check if updates are available for the requirement
-     * @param requirement The requirement to check
-     * @param currentStatus The current status of the requirement
-     * @returns The status of the requirement with update information
-     */
-    checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
-}
-
-// Note: Do not re-export implementations from here to avoid circular dependencies