imcp 0.0.14 → 0.0.16

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

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, OSType } from '../../types.js';
+import { RequirementConfig, RequirementStatus, OSType, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 import { getOSType, refreshPathEnv } from '../../../utils/osUtils.js';
 import { Logger } from '../../../utils/logger.js';
@@ -16,6 +16,14 @@ interface CommandMapping {
  */
 export class CommandInstaller extends BaseInstaller {
 
+    /**
+     * Constructor for the CommandInstaller
+     * @param execPromise Function to execute commands
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined> {
+        throw new Error('Method not implemented.');
+    }
+
     /**
      * Mapping of command names to their package IDs
      * This handles special cases where the command name differs from the package ID

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

@@ -1,12 +1,21 @@
-import { RequirementConfig, RequirementStatus } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+import { handleArtifact } from '../../../utils/adoUtils.js';
 
 /**
  * Installer implementation for general requirements (type 'other')
  * This installer handles requirements that don't fit into specific package manager categories
  */
 export class GeneralInstaller extends BaseInstaller {
+
+    /**
+     * Constructor for the GeneralInstaller
+     * @param execPromise Function to execute commands
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined> {
+        throw new Error('Method not implemented.');
+    }
     /**
      * Check if this installer can handle the given requirement type
      * @param requirement The requirement to check
@@ -59,9 +68,7 @@ export class GeneralInstaller extends BaseInstaller {
                 const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
                 installPath = result.resolvedPath;
             } else if (requirement.registry.artifacts) {
-                installPath = await this.handleArtifactsRegistry(requirement, requirement.registry.artifacts);
-            } else if (requirement.registry.local) {
-                installPath = await this.handleLocalRegistry(requirement, requirement.registry.local);
+                await handleArtifact(requirement, requirement.registry.artifacts);
             } else {
                 throw new Error('Invalid registry configuration');
             }

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

@@ -1,8 +1,13 @@
-import { stat } from 'fs';
-import { RequirementConfig, RequirementStatus } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 import { compareVersions } from '../../../utils/versionUtils.js';
-import { handleGitHubRelease } from '../../../utils/githubUtils.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 '../../constants.js'; // Corrected path
+import { Logger } from '../../../utils/logger.js';
 /**
  * Installer implementation for NPM packages
  */
@@ -19,105 +24,217 @@ export class NpmInstaller extends BaseInstaller {
     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();
+    }
+
     /**
-     * Check if the NPM package is already installed
+     * 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): Promise<RequirementStatus> {
+    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 { stdout } = await this.execPromise(`npm list -g ${requirement.name} --json`);
-            const pkgInfo = JSON.parse(stdout);
-            const installedVersion = pkgInfo?.dependencies?.[requirement.name]?.version;
+            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: !!installedVersion,
-                version: installedVersion,
-                inProgress: false
+                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),
-                inProgress: false
             };
         }
     }
 
     /**
-     * Install the NPM package
-     * @param requirement The requirement to install
-     * @returns The status of the installation
+     * 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
      */
-    async install(requirement: RequirementConfig): Promise<RequirementStatus> {
+    private async _getInstalledVersion(requirementName: string, directory: string): Promise<string | undefined> {
         try {
-            const status = await this.checkInstallation(requirement);
-            if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0) {
-                return status;
+            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
+        }
+    }
 
-            let resolvedVersion = requirement.version;
 
-            // If no registry is specified, use standard npm installation
-            if (!requirement.registry) {
-                const { stderr } = await this.execPromise(`npm install -g ${requirement.name}@${requirement.version}`);
-                if (stderr && !stderr.includes('added')) {
-                    throw new Error(stderr);
-                }
+    /**
+     * 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
+    ): 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);
+        
+        try {
+            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 {
-                // Handle different registry types
-                let packageSource: string;
+                throw new Error(`Successfully ran npm install for ${packageSource}, but ${requirement.name} version could not be determined via npm list in ${targetDir}.`);
+            }
+
+        } catch (error) {
+            Logger.error(`Failed to install or verify NPM package ${packageSource} into ${targetDir}`, error);
+            throw error;
+        }
+    }
+
 
+    /**
+     * Install the NPM package.
+     * @param requirement The requirement to install.
+     * @param options Installation options, including pythonCommand for ADO (though not used by npm) and folderName.
+     * @returns The status of the installation.
+     */
+    async install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        const targetDir = options?.settings?.folderName || this._getRequirementFolderPath(requirement);
+        await fs.mkdir(targetDir, { recursive: true }); 
+
+        try {
+            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);
-                    packageSource = result.resolvedPath;
+                    packageToInstall = result.resolvedPath; 
                     resolvedVersion = result.resolvedVersion;
                 } else if (requirement.registry.artifacts) {
-                    // For npm with artifacts, configure npm to use the specified registry URL
-                    const registryUrl = requirement.registry.artifacts.registryUrl;
-                    await this.execPromise(`npm config set registry ${registryUrl}`);
-
-                    // Now install the package with the configured registry
-                    const { stderr } = await this.execPromise(`npm install -g ${requirement.name}@${requirement.version}`);
-                    if (stderr && !stderr.includes('added')) {
-                        // Reset the registry to the default npm registry
-                        await this.execPromise('npm config set registry https://registry.npmjs.org/');
-                        throw new Error(stderr);
-                    }
-
-                    // Reset the registry to the default npm registry
-                    await this.execPromise('npm config set registry https://registry.npmjs.org/');
-                    return {
-                        name: requirement.name,
-                        type: 'npm',
-                        installed: true,
-                        version: requirement.version,
-                        inProgress: false
-                    };
-                } else if (requirement.registry.local) {
-                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
+                    const adoResult: AdoArtifactResult = await handleAdoArtifact(
+                        requirement,
+                        requirement.registry.artifacts,
+                        options?.settings?.pythonCommand, 
+                        targetDir 
+                    );
+                    packageToInstall = `${adoResult.package}@${adoResult.version}`;
+                    resolvedVersion = adoResult.version;
                 } else {
-                    throw new Error('Invalid registry configuration');
-                }
-
-                // Install from the package source
-                const { stderr } = await this.execPromise(`npm install -g "${packageSource}"`);
-                if (stderr && !stderr.includes('added')) {
-                    const status = await this.checkInstallation(requirement);
-                    if (!status.installed) throw new Error(stderr);
+                    throw new Error('Invalid registry configuration for npm.');
                 }
             }
+            const finalInstallResult = await this._installPackage(requirement, packageToInstall, targetDir);
+            resolvedVersion = finalInstallResult.version;
+
 
             return {
                 name: requirement.name,
                 type: 'npm',
                 installed: true,
                 version: resolvedVersion,
-                inProgress: false
+                inProgress: false,
+                npmPath: targetDir
             };
         } catch (error) {
             return {

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

@@ -1,6 +1,10 @@
 import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
+// Assuming getArtifactLatestVersion will be available in adoUtils.ts
+import { handleArtifact as handleAdoArtifact, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { Logger } from '../../../utils/logger.js';
 
 /**
  * Installer implementation for Python packages using pip
@@ -14,6 +18,7 @@ export class PipInstaller extends BaseInstaller {
         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
@@ -24,12 +29,56 @@ export class PipInstaller extends BaseInstaller {
     }
 
     supportCheckUpdates(): boolean {
-        /// temporarily disabling update check for pip as not able to get which pip of python is being used
         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> {
@@ -37,18 +86,17 @@ export class PipInstaller extends BaseInstaller {
             const pipCmd = this.getPipCommand(options);
             const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
 
-            // If we get an output and no error, the package is installed
-            const installed = stdout.includes(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: installed,
                 version: installedVersion,
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv in status check too
+                pythonEnv: this.getPythonCommand(options)
             };
         } catch (error) {
             return {
@@ -57,7 +105,7 @@ export class PipInstaller extends BaseInstaller {
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv even in error case
+                pythonEnv: this.getPythonCommand(options)
             };
         }
     }
@@ -65,68 +113,59 @@ export class PipInstaller extends BaseInstaller {
     /**
      * Install the Python package
      * @param requirement The requirement to install
+     * @param options Optional server install options
      * @returns The status of the installation
      */
     async install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
         try {
             const status = await this.checkInstallation(requirement, options);
-            if (status.installed) {
+            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);
 
-            // If no registry is specified, use standard pip installation
             if (!requirement.registry) {
-                // Standard pip installation
                 const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
                 if (stderr && stderr.toLowerCase().includes('error')) {
                     throw new Error(stderr);
                 }
             } else {
-                // Handle different registry types
                 let packageSource: string;
 
                 if (requirement.registry.githubRelease) {
                     const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
                     packageSource = result.resolvedPath;
-
-                    // Install from the downloaded wheel or tar.gz file
                     const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }
                 } else if (requirement.registry.artifacts) {
-                    const registryUrl = requirement.registry.artifacts.registryUrl;
+                    const pythonCmd = this.getPythonCommand(options);
+                    const adoArtifactResult = await handleAdoArtifact(requirement, requirement.registry.artifacts, pythonCmd);
 
-                    // Install using the custom index URL
                     const { stderr } = await this.execPromise(
-                        `${pipCmd} install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`
+                        `${pipCmd} install ${adoArtifactResult.package} --extra-index-url ${adoArtifactResult.registryUrl}`
                     );
                     if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
-                    }
-                } else if (requirement.registry.local) {
-                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
-
-                    // Install from the local path
-                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
+                        const checkStatus = await this.checkInstallation(requirement, options);
+                        if (!checkStatus.installed) {
+                            throw new Error(`Pip installation failed with: ${stderr}`);
+                        }
                     }
                 } else {
                     throw new Error('Invalid registry configuration');
                 }
             }
 
-            // Store the pythonEnv in the status for future use
             return {
                 name: requirement.name,
                 type: 'pip',
                 installed: true,
-                version: requirement.version,
+                version: requirement.version, // This might need to be updated to actual installed version
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Store the python env
+                pythonEnv: this.getPythonCommand(options)
             };
         } catch (error) {
             return {
@@ -135,7 +174,7 @@ export class PipInstaller extends BaseInstaller {
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Store the python env
+                pythonEnv: this.getPythonCommand(options)
             };
         }
     }