imcp 0.0.14 → 0.0.16

package/dist/core/installers/requirements/BaseInstaller.js

@@ -1,7 +1,6 @@
 import path from 'path';
-import fs from 'fs/promises';
 import { SETTINGS_DIR } from '../../constants.js';
-import { extractZipFile } from '../../../utils/clientUtils.js';
+import { Logger } from '../../../utils/logger.js';
 /**
  * Abstract base class with common functionality for all requirement installers
  */
@@ -16,9 +15,10 @@ export class BaseInstaller {
      * Check if updates are available for the requirement
      * @param requirement The requirement to check
      * @param currentStatus The current status of the requirement
+     * @param options Optional server install options.
      * @returns The status of the requirement with update information
      */
-    async checkForUpdates(requirement, currentStatus) {
+    async checkForUpdates(requirement, currentStatus, options) {
         try {
             // If requirement is not installed, no need to check for updates
             if (!currentStatus.installed) {
@@ -28,23 +28,7 @@ export class BaseInstaller {
             if (!requirement.version.includes('latest')) {
                 return currentStatus;
             }
-            let latestVersion;
-            // Check based on registry type
-            if (requirement.registry?.githubRelease) {
-                latestVersion = await this.getGitHubLatestVersion(requirement.registry.githubRelease.repository);
-            }
-            else {
-                // Use common practice based on requirement type
-                switch (requirement.type) {
-                    case 'npm':
-                        latestVersion = await this.getNpmLatestVersion(requirement.name);
-                        break;
-                    case 'pip':
-                        latestVersion = await this.getPipLatestVersion(requirement.name);
-                        break;
-                    // Add other types as needed
-                }
-            }
+            const latestVersion = await this.getLatestVersion(requirement, options);
             // If we found a latest version and it's different from current
             if (latestVersion && latestVersion !== currentStatus.version) {
                 return {
@@ -65,104 +49,9 @@ export class BaseInstaller {
         }
         catch (error) {
             // Don't update status on error, just log it
-            console.warn(`Error checking for updates for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            Logger.log(`Error checking for updates for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
             return currentStatus;
         }
     }
-    /**
-     * Helper to handle artifact registry downloads
-     * @param requirement The requirement configuration
-     * @param registry The artifacts registry configuration
-     * @returns The registry URL
-     */
-    async handleArtifactsRegistry(requirement, registry) {
-        if (!registry) {
-            throw new Error('Artifacts registry configuration is required');
-        }
-        const { registryUrl, assetName } = registry;
-        if (!registryUrl) {
-            throw new Error('Registry URL is required for artifacts downloads');
-        }
-        return registryUrl;
-    }
-    /**
-     * Helper to handle local path registry
-     * @param requirement The requirement configuration
-     * @param registry The local registry configuration
-     * @returns The local path or extracted asset path
-     */
-    async handleLocalRegistry(requirement, registry) {
-        if (!registry) {
-            throw new Error('Local registry configuration is required');
-        }
-        const { localPath, assetName } = registry;
-        if (!localPath) {
-            throw new Error('Local path is required for local registry');
-        }
-        // Verify the local path exists
-        try {
-            await fs.access(localPath);
-        }
-        catch (error) {
-            throw new Error(`Local path ${localPath} does not exist or is not accessible`);
-        }
-        // If the path is a zip file and assetName is specified, extract it
-        if (localPath.endsWith('.zip') && assetName) {
-            const extractDir = path.join(this.downloadsDir, path.basename(localPath, '.zip'));
-            await fs.mkdir(extractDir, { recursive: true });
-            // Extract the zip file
-            await extractZipFile(localPath, { dir: extractDir });
-            // Find the asset in the extracted directory
-            const assetPath = path.join(extractDir, assetName);
-            try {
-                await fs.access(assetPath);
-                return assetPath;
-            }
-            catch (error) {
-                throw new Error(`Asset ${assetName} not found in extracted directory ${extractDir}`);
-            }
-        }
-        return localPath;
-    }
-    /**
-     * Get the latest version available for a GitHub repository
-     * @param repository The GitHub repository in format 'owner/repo'
-     * @returns The latest version or tag
-     */
-    async getGitHubLatestVersion(repository) {
-        try {
-            // Use GitHub CLI to get the latest release
-            const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
-            const latestTag = stdout.trim();
-            // Remove 'v' prefix if present
-            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
-        }
-        catch (error) {
-            // If gh command fails, try to get the latest tag
-            const { stdout } = await this.execPromise(`git ls-remote --tags --refs https://github.com/${repository}.git | sort -t '/' -k 3 -V | tail -n 1 | awk -F/ '{print $3}'`);
-            let latestTag = stdout.trim();
-            // Remove 'v' prefix if present
-            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
-        }
-    }
-    /**
-     * Get the latest version available for an NPM package
-     * @param packageName The name of the NPM package
-     * @returns The latest version
-     */
-    async getNpmLatestVersion(packageName) {
-        const { stdout } = await this.execPromise(`npm view ${packageName} version`);
-        return stdout.trim();
-    }
-    /**
-     * Get the latest version available for a pip package
-     * @param packageName The name of the pip package
-     * @returns The latest version
-     */
-    async getPipLatestVersion(packageName, options) {
-        const pythonCmd = options?.settings?.pythonEnv || 'python';
-        const { stdout } = await this.execPromise(`${pythonCmd} -m pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
-        return stdout.trim();
-    }
 }
 //# sourceMappingURL=BaseInstaller.js.map

package/dist/core/installers/requirements/CommandInstaller.d.ts

@@ -1,9 +1,14 @@
-import { RequirementConfig, RequirementStatus } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for command-line tools
  */
 export declare class CommandInstaller extends BaseInstaller {
+    /**
+     * Constructor for the CommandInstaller
+     * @param execPromise Function to execute commands
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined>;
     /**
      * Mapping of command names to their package IDs
      * This handles special cases where the command name differs from the package ID

package/dist/core/installers/requirements/CommandInstaller.js

@@ -6,6 +6,13 @@ import { Logger } from '../../../utils/logger.js';
  * Installer implementation for command-line tools
  */
 export class CommandInstaller extends BaseInstaller {
+    /**
+     * Constructor for the CommandInstaller
+     * @param execPromise Function to execute commands
+     */
+    getLatestVersion(requirement, options) {
+        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/dist/core/installers/requirements/GeneralInstaller.d.ts

@@ -1,10 +1,15 @@
-import { RequirementConfig, RequirementStatus } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for general requirements (type 'other')
  * This installer handles requirements that don't fit into specific package manager categories
  */
 export declare class GeneralInstaller extends BaseInstaller {
+    /**
+     * Constructor for the GeneralInstaller
+     * @param execPromise Function to execute commands
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined>;
     /**
      * Check if this installer can handle the given requirement type
      * @param requirement The requirement to check

package/dist/core/installers/requirements/GeneralInstaller.js

@@ -1,10 +1,18 @@
 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, options) {
+        throw new Error('Method not implemented.');
+    }
     /**
      * Check if this installer can handle the given requirement type
      * @param requirement The requirement to check
@@ -54,10 +62,7 @@ export class GeneralInstaller extends BaseInstaller {
                 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/dist/core/installers/requirements/NpmInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for NPM packages
@@ -12,15 +12,54 @@ export declare class NpmInstaller extends BaseInstaller {
     canHandle(requirement: RequirementConfig): boolean;
     supportCheckUpdates(): boolean;
     /**
-     * Check if the NPM package is already installed
+     * 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.
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined>;
+    /**
+     * 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;
+    /**
+     * 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
      */
-    checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * 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 _getInstalledVersion;
+    /**
+     * Get the name of the requirement, including registry information if applicable.
+     * @param requirement The requirement configuration.
+     * @returns The formatted requirement name.
+     * @private
+     */
+    private _getRequirementName;
+    /**
+     * 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 _installPackage;
     /**
-     * Install the NPM package
-     * @param requirement The requirement to install
-     * @returns The status of the installation
+     * 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.
      */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
 }

package/dist/core/installers/requirements/NpmInstaller.js

@@ -1,6 +1,12 @@
 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, 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
  */
@@ -17,101 +23,187 @@ export class NpmInstaller extends BaseInstaller {
         return true;
     }
     /**
-     * Check if the NPM package is already installed
+     * 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, options) {
+        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
+     */
+    _getRequirementFolderPath(requirement) {
+        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) {
+    async checkInstallation(requirement, options) {
+        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) {
+    async _getInstalledVersion(requirementName, directory) {
         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;
             }
-            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);
-                }
+            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
+     */
+    _getRequirementName(requirement) {
+        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.
+     */
+    async _installPackage(requirement, packageSource, targetDir) {
+        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;
+                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, options) {
+        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 = `${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 = 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) {

package/dist/core/installers/requirements/PipInstaller.d.ts

@@ -13,15 +13,24 @@ export declare class PipInstaller extends BaseInstaller {
      */
     canHandle(requirement: RequirementConfig): boolean;
     supportCheckUpdates(): boolean;
+    /**
+     * 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.
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined>;
     /**
      * 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
      */
     checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Install the Python package
      * @param requirement The requirement to install
+     * @param options Optional server install options
      * @returns The status of the installation
      */
     install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;