imcp 0.1.5 → 0.1.6

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

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

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

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