imcp 0.1.7 → 0.1.8-dev

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

@@ -1,127 +1,2 @@
-import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease } from '../../../utils/githubUtils.js';
-import { handleArtifact } from '../../../utils/adoUtils.js';
-import * as RecordingConstants from '../../metadatas/recordingConstants.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
-     * @returns True if this installer can handle the requirement
-     */
-    canHandle(requirement) {
-        return requirement.type === 'other';
-    }
-    supportCheckUpdates() {
-        return false;
-    }
-    /**
-     * Check if the requirement is already installed
-     * For general installers, we can't easily check if something is installed
-     * without specific knowledge of the requirement, so we always return false
-     *
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    async checkInstallation(requirement) {
-        // For general installers, we can't easily check if something is installed
-        // So we'll always return not installed, and the actual installation will check
-        return {
-            name: requirement.name,
-            type: 'other',
-            installed: false,
-            inProgress: false
-        };
-    }
-    /**
-     * Install the general requirement
-     * For type 'other', this doesn't actually install anything, but downloads
-     * or locates the asset and returns the path for the caller to use
-     *
-     * @param requirement The requirement to install
-     * @returns The status of the installation, including the install path in updateInfo
-     */
-    /**
-     * Install the general requirement
-     * For type 'other', this doesn't actually install anything, but downloads
-     * or locates the asset and returns the path for the caller to use
-     * @param requirement The requirement to install
-     * @param options Optional install options
-     * @param recorder Optional InstallOperationManager for recording steps
-     * @returns The status of the installation, including the install path in updateInfo
-     */
-    async install(requirement, recorder, options) {
-        const doInstall = async () => {
-            // For type 'other', a registry must be specified
-            if (!requirement.registry) {
-                throw new Error('Registry must be specified for requirement type "other"');
-            }
-            let installPath;
-            if (requirement.registry.githubRelease) {
-                const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                installPath = result.resolvedPath;
-            }
-            else if (requirement.registry.artifacts) {
-                await handleArtifact(requirement, requirement.registry.artifacts);
-            }
-            else {
-                throw new Error('Invalid registry configuration');
-            }
-            // For general installer, we just return the path to the downloaded/located file
-            // The actual installation mechanism would depend on the specific requirement
-            return {
-                name: requirement.name,
-                type: 'other',
-                installed: true,
-                version: requirement.version,
-                inProgress: false,
-            };
-        };
-        if (recorder) {
-            return recorder.recording(doInstall, {
-                stepName: RecordingConstants.STEP_GENERAL_INSTALLER_INSTALL,
-                inProgressMessage: `Installing general requirement: ${requirement.name}`,
-                endMessage: (result) => result.installed
-                    ? `Install completed for ${requirement.name}`
-                    : `Install failed for ${requirement.name}`,
-                onError: (error) => {
-                    return {
-                        result: {
-                            name: requirement.name,
-                            type: 'other',
-                            installed: false,
-                            error: error instanceof Error ? error.message : String(error),
-                            inProgress: false,
-                        },
-                        message: error instanceof Error ? error.message : String(error),
-                    };
-                },
-            });
-        }
-        else {
-            try {
-                return await doInstall();
-            }
-            catch (error) {
-                return {
-                    name: requirement.name,
-                    type: 'other',
-                    installed: false,
-                    error: error instanceof Error ? error.message : String(error),
-                    inProgress: false,
-                };
-            }
-        }
-    }
-}
+import{BaseInstaller}from"./BaseInstaller.js";import{handleGitHubRelease}from"../../../utils/githubUtils.js";import{handleArtifact}from"../../../utils/adoUtils.js";import*as RecordingConstants from"../../metadatas/recordingConstants.js";export class GeneralInstaller extends BaseInstaller{getLatestVersion(e,r){throw new Error("Method not implemented.")}canHandle(e){return"other"===e.type}supportCheckUpdates(){return!1}async checkInstallation(e){return{name:e.name,type:"other",installed:!1,inProgress:!1}}async install(e,r,t){const s=async()=>{if(!e.registry)throw new Error('Registry must be specified for requirement type "other"');let r;if(e.registry.githubRelease)r=(await handleGitHubRelease(e,e.registry.githubRelease)).resolvedPath;else{if(!e.registry.artifacts)throw new Error("Invalid registry configuration");await handleArtifact(e,e.registry.artifacts)}return{name:e.name,type:"other",installed:!0,version:e.version,inProgress:!1}};if(r)return r.recording(s,{stepName:RecordingConstants.STEP_GENERAL_INSTALLER_INSTALL,inProgressMessage:`Installing general requirement: ${e.name}`,endMessage:r=>r.installed?`Install completed for ${e.name}`:`Install failed for ${e.name}`,onError:r=>({result:{name:e.name,type:"other",installed:!1,error:r instanceof Error?r.message:String(r),inProgress:!1},message:r instanceof Error?r.message:String(r)})});try{return await s()}catch(r){return{name:e.name,type:"other",installed:!1,error:r instanceof Error?r.message:String(r),inProgress:!1}}}}
 //# sourceMappingURL=GeneralInstaller.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["BaseInstaller","handleGitHubRelease","handleArtifact","RecordingConstants","GeneralInstaller","getLatestVersion","requirement","options","Error","canHandle","type","supportCheckUpdates","checkInstallation","name","installed","inProgress","install","recorder","doInstall","async","registry","installPath","githubRelease","resolvedPath","artifacts","version","recording","stepName","STEP_GENERAL_INSTALLER_INSTALL","inProgressMessage","endMessage","result","onError","error","message","String"],"sources":["../../../../src/core/installers/requirements/GeneralInstaller.ts"],"mappings":"OACSA,kBAAqB,4BACrBC,wBAA2B,uCAC3BC,mBAAsB,uCAEnBC,uBAAwB,+CAM9B,MAAOC,yBAAyBJ,cAMlC,gBAAAK,CAAiBC,EAAgCC,GAC7C,MAAM,IAAIC,MAAM,0BACpB,CAMA,SAAAC,CAAUH,GACN,MAA4B,UAArBA,EAAYI,IACvB,CAEA,mBAAAC,GACI,OAAO,CACX,CASA,uBAAMC,CAAkBN,GAGpB,MAAO,CACHO,KAAMP,EAAYO,KAClBH,KAAM,QACNI,WAAW,EACXC,YAAY,EAEpB,CAmBA,aAAMC,CAAQV,EAAgCW,EAAmCV,GAC7E,MAAMW,EAAYC,UAEd,IAAKb,EAAYc,SACb,MAAM,IAAIZ,MAAM,2DAGpB,IAAIa,EAEJ,GAAIf,EAAYc,SAASE,cAErBD,SADqBpB,oBAAoBK,EAAaA,EAAYc,SAASE,gBACtDC,iBAClB,KAAIjB,EAAYc,SAASI,UAG5B,MAAM,IAAIhB,MAAM,wCAFVN,eAAeI,EAAaA,EAAYc,SAASI,UAG3D,CAIA,MAAO,CACHX,KAAMP,EAAYO,KAClBH,KAAM,QACNI,WAAW,EACXW,QAASnB,EAAYmB,QACrBV,YAAY,EACf,EAGL,GAAIE,EACA,OAAOA,EAASS,UAAUR,EAAW,CACjCS,SAAUxB,mBAAmByB,+BAC7BC,kBAAmB,mCAAmCvB,EAAYO,OAClEiB,WAAaC,GACTA,EAAOjB,UACD,yBAAyBR,EAAYO,OACrC,sBAAsBP,EAAYO,OAC5CmB,QAAUC,IACC,CACHF,OAAQ,CACJlB,KAAMP,EAAYO,KAClBH,KAAM,QACNI,WAAW,EACXmB,MAAOA,aAAiBzB,MAAQyB,EAAMC,QAAUC,OAAOF,GACvDlB,YAAY,GAEhBmB,QAASD,aAAiBzB,MAAQyB,EAAMC,QAAUC,OAAOF,OAKrE,IACI,aAAaf,GACjB,CAAE,MAAOe,GACL,MAAO,CACHpB,KAAMP,EAAYO,KAClBH,KAAM,QACNI,WAAW,EACXmB,MAAOA,aAAiBzB,MAAQyB,EAAMC,QAAUC,OAAOF,GACvDlB,YAAY,EAEpB,CAER","ignoreList":[]}

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

@@ -1,100 +1,2 @@
-import { NpmInstaller } from './NpmInstaller.js';
-import { PipInstaller } from './PipInstaller.js';
-import { NugetInstaller } from './NugetInstaller.js';
-import { CommandInstaller } from './CommandInstaller.js';
-import { GeneralInstaller } from './GeneralInstaller.js';
-import { exec } from 'child_process';
-import util from 'util';
-/**
- * Factory for creating the appropriate installer for a requirement
- */
-export class InstallerFactory {
-    installers = [];
-    execPromise;
-    /**
-     * Create a new InstallerFactory
-     * @param execPromise Function to execute commands
-     */
-    constructor(execPromise) {
-        this.execPromise = execPromise;
-        this.registerDefaultInstallers();
-    }
-    /**
-     * Register default installers for npm, pip, and general requirements
-     * @private
-     */
-    registerDefaultInstallers() {
-        this.registerInstaller(new NpmInstaller(this.execPromise));
-        this.registerInstaller(new PipInstaller(this.execPromise));
-        this.registerInstaller(new NugetInstaller(this.execPromise));
-        this.registerInstaller(new CommandInstaller(this.execPromise));
-        this.registerInstaller(new GeneralInstaller(this.execPromise));
-    }
-    /**
-     * Register a custom installer
-     * @param installer The installer to register
-     */
-    registerInstaller(installer) {
-        this.installers.push(installer);
-    }
-    /**
-     * Get the appropriate installer for a requirement
-     * @param requirement The requirement to get an installer for
-     * @returns The appropriate installer, or undefined if none found
-     */
-    getInstaller(requirement) {
-        // Validate that if registry is empty, type must not be 'other'
-        if (!requirement.registry && requirement.type === 'other') {
-            throw new Error('Registry must be specified for requirement type "other"');
-        }
-        return this.installers.find(installer => installer.canHandle(requirement));
-    }
-    /**
-     * Install a requirement using the appropriate installer
-     * @param requirement The requirement to install
-     * @param recorder Optional InstallOperationManager for recording steps
-     * @param options Installation options including python environment
-     * @returns The installation status
-     */
-    async install(requirement, recorder, options) {
-        const installer = this.getInstaller(requirement);
-        if (!installer) {
-            return {
-                name: requirement.name,
-                type: requirement.type,
-                installed: false,
-                error: `No installer found for requirement type '${requirement.type}'`,
-                inProgress: false
-            };
-        }
-        return await installer.install(requirement, recorder, options);
-    }
-    /**
-      * Check the installation status of a requirement
-      * @param requirement The requirement to check
-      * @param options Installation options including python environment
-      * @returns The installation status
-      */
-    async checkInstallation(requirement, options) {
-        const installer = this.getInstaller(requirement);
-        if (!installer) {
-            return {
-                name: requirement.name,
-                type: requirement.type,
-                installed: false,
-                error: `No installer found for requirement type '${requirement.type}'`,
-                inProgress: false
-            };
-        }
-        return await installer.checkInstallation(requirement, options);
-    }
-}
-/**
- * Create a new InstallerFactory with default settings
- * @param execPromise Optional function to execute commands
- * @returns A new InstallerFactory
- */
-export const createInstallerFactory = (execPromise = util.promisify(exec)) => {
-    return new InstallerFactory(execPromise);
-};
+import{NpmInstaller}from"./NpmInstaller.js";import{PipInstaller}from"./PipInstaller.js";import{NugetInstaller}from"./NugetInstaller.js";import{CommandInstaller}from"./CommandInstaller.js";import{GeneralInstaller}from"./GeneralInstaller.js";import{exec}from"child_process";import util from"util";export class InstallerFactory{installers=[];execPromise;constructor(e){this.execPromise=e,this.registerDefaultInstallers()}registerDefaultInstallers(){this.registerInstaller(new NpmInstaller(this.execPromise)),this.registerInstaller(new PipInstaller(this.execPromise)),this.registerInstaller(new NugetInstaller(this.execPromise)),this.registerInstaller(new CommandInstaller(this.execPromise)),this.registerInstaller(new GeneralInstaller(this.execPromise))}registerInstaller(e){this.installers.push(e)}getInstaller(e){if(!e.registry&&"other"===e.type)throw new Error('Registry must be specified for requirement type "other"');return this.installers.find((t=>t.canHandle(e)))}async install(e,t,r){const s=this.getInstaller(e);return s?await s.install(e,t,r):{name:e.name,type:e.type,installed:!1,error:`No installer found for requirement type '${e.type}'`,inProgress:!1}}async checkInstallation(e,t){const r=this.getInstaller(e);return r?await r.checkInstallation(e,t):{name:e.name,type:e.type,installed:!1,error:`No installer found for requirement type '${e.type}'`,inProgress:!1}}}export const createInstallerFactory=(e=util.promisify(exec))=>new InstallerFactory(e);
 //# sourceMappingURL=InstallerFactory.js.map

package/dist/core/installers/requirements/InstallerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NpmInstaller","PipInstaller","NugetInstaller","CommandInstaller","GeneralInstaller","exec","util","InstallerFactory","installers","execPromise","constructor","this","registerDefaultInstallers","registerInstaller","installer","push","getInstaller","requirement","registry","type","Error","find","canHandle","install","recorder","options","name","installed","error","inProgress","checkInstallation","createInstallerFactory","promisify"],"sources":["../../../../src/core/installers/requirements/InstallerFactory.ts"],"mappings":"OAESA,iBAAoB,2BACpBC,iBAAoB,2BACpBC,mBAAsB,6BACtBC,qBAAwB,+BACxBC,qBAAwB,+BACxBC,SAAY,uBACdC,SAAU,cAKX,MAAOC,iBACDC,WAAqC,GAC5BC,YAMjB,WAAAC,CAAYD,GACRE,KAAKF,YAAcA,EACnBE,KAAKC,2BACT,CAMQ,yBAAAA,GACJD,KAAKE,kBAAkB,IAAIb,aAAaW,KAAKF,cAC7CE,KAAKE,kBAAkB,IAAIZ,aAAaU,KAAKF,cAC7CE,KAAKE,kBAAkB,IAAIX,eAAeS,KAAKF,cAC/CE,KAAKE,kBAAkB,IAAIV,iBAAiBQ,KAAKF,cACjDE,KAAKE,kBAAkB,IAAIT,iBAAiBO,KAAKF,aACrD,CAMO,iBAAAI,CAAkBC,GACrBH,KAAKH,WAAWO,KAAKD,EACzB,CAOO,YAAAE,CAAaC,GAEhB,IAAKA,EAAYC,UAAiC,UAArBD,EAAYE,KACrC,MAAM,IAAIC,MAAM,2DAGpB,OAAOT,KAAKH,WAAWa,MAAKP,GAAaA,EAAUQ,UAAUL,IACjE,CASO,aAAMM,CAAQN,EAAgCO,EAAmCC,GACpF,MAAMX,EAAYH,KAAKK,aAAaC,GACpC,OAAKH,QAUQA,EAAUS,QAAQN,EAAaO,EAAUC,GAT3C,CACHC,KAAMT,EAAYS,KAClBP,KAAMF,EAAYE,KAClBQ,WAAW,EACXC,MAAO,4CAA4CX,EAAYE,QAC/DU,YAAY,EAKxB,CAQO,uBAAMC,CAAkBb,EAAgCQ,GAC3D,MAAMX,EAAYH,KAAKK,aAAaC,GACpC,OAAKH,QAUQA,EAAUgB,kBAAkBb,EAAaQ,GAT3C,CACHC,KAAMT,EAAYS,KAClBP,KAAMF,EAAYE,KAClBQ,WAAW,EACXC,MAAO,4CAA4CX,EAAYE,QAC/DU,YAAY,EAKxB,SAQG,MAAME,uBAAyB,CAClCtB,EAAcH,KAAK0B,UAAU3B,QAEtB,IAAIE,iBAAiBE","ignoreList":[]}

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

@@ -1,236 +1,2 @@
-import { BaseInstaller } from './BaseInstaller.js';
-import { compareVersions } from '../../../utils/versionUtils.js';
-import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
-// Assuming getArtifactLatestVersion will be available in adoUtils.ts
-import { handleArtifact as handleAdoArtifact, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
-import path from 'path';
-import fs from 'fs/promises';
-import { SETTINGS_DIR } from '../../metadatas/constants.js'; // Corrected path
-import { Logger } from '../../../utils/logger.js';
-import * as RecordingConstants from '../../metadatas/recordingConstants.js';
-/**
- * Installer implementation for NPM packages
- */
-export class NpmInstaller extends BaseInstaller {
-    /**
-     * Check if this installer can handle the given requirement type
-     * @param requirement The requirement to check
-     * @returns True if this installer can handle the requirement
-     */
-    canHandle(requirement) {
-        return requirement.type === 'npm';
-    }
-    supportCheckUpdates() {
-        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, 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, options) {
-        const requirementDir = options?.settings?.folderName || this._getRequirementFolderPath(requirement);
-        const requirementName = this._getRequirementName(requirement);
-        Logger.debug(`Checking installation for ${requirementName} in ${requirementDir}`);
-        try {
-            const installedVersion = await this._getInstalledVersion(requirementName, requirementDir);
-            if (installedVersion) {
-                return {
-                    name: requirement.name,
-                    type: 'npm',
-                    installed: true,
-                    version: installedVersion,
-                    npmPath: requirementDir,
-                    inProgress: false,
-                };
-            }
-            // If package not found in dependencies or version is missing
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: false,
-                inProgress: false,
-                error: `Package ${requirement.name} not found or version missing in npm list output in ${requirementDir}.`,
-            };
-        }
-        catch (error) {
-            // npm list command likely failed (e.g., package not installed, or requirementDir not an npm project)
-            Logger.debug(`Error checking installation for ${requirement.name} in ${requirementDir}: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: false,
-                inProgress: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Retrieves the installed version of an NPM package from a given directory.
-     * @param requirementName The name of the NPM package.
-     * @param directory The directory to check for the package.
-     * @returns The installed version string, or undefined if not found or an error occurs.
-     * @private
-     */
-    async _getInstalledVersion(requirementName, directory) {
-        try {
-            const command = `npm list ${requirementName} --depth=0 --json --prefix "${directory}"`;
-            Logger.debug(`Getting installed version for ${requirementName} in ${directory} with command: ${command}`);
-            const { stdout } = await this.execPromise(command);
-            const listOutput = JSON.parse(stdout);
-            if (listOutput.dependencies && listOutput.dependencies[requirementName] && listOutput.dependencies[requirementName].version) {
-                return listOutput.dependencies[requirementName].version;
-            }
-            Logger.debug(`Package ${requirementName} not found in npm list output in ${directory}.`);
-            return undefined;
-        }
-        catch (error) {
-            Logger.debug(`Error getting installed version for ${requirementName} in ${directory}: ${error instanceof Error ? error.message : String(error)}`);
-            return undefined; // Return undefined on error to indicate version couldn't be retrieved
-        }
-    }
-    /**
-     * Get the name of the requirement, including registry information if applicable.
-     * @param requirement The requirement configuration.
-     * @returns The formatted requirement name.
-     * @private
-     */
-    _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, recorder) {
-        Logger.debug(`Installing NPM package from "${packageSource}" into "${targetDir}"`);
-        await fs.mkdir(targetDir, { recursive: true });
-        const installCommand = `npm install ${packageSource} --prefix "${targetDir}"`;
-        Logger.debug(`Executing install command: ${installCommand}`);
-        const requirementName = this._getRequirementName(requirement);
-        return await recorder.recording(async () => {
-            const { stdout: installStdout, stderr: installStderr } = await this.execPromise(installCommand);
-            Logger.debug(`NPM install stdout for ${packageSource} in ${targetDir}: ${installStdout}`);
-            if (installStderr && !installStderr.toLowerCase().includes('added') && !installStderr.toLowerCase().includes('updated') && !installStderr.toLowerCase().includes('found 0 vulnerabilities')) {
-                // Log stderr if it's not just typical success noise
-                Logger.log(`NPM install stderr for ${packageSource} in ${targetDir}: ${installStderr}`);
-            }
-            const installedVersion = await this._getInstalledVersion(requirementName, targetDir);
-            if (installedVersion) {
-                Logger.log(`Successfully installed and verified ${requirementName}@${installedVersion} into ${targetDir}`);
-                return { version: installedVersion };
-            }
-            else {
-                throw new Error(`Successfully ran npm install for ${packageSource}, but ${requirement.name} version could not be determined via npm list in ${targetDir}, stderr: ${installStderr}`);
-            }
-        }, {
-            stepName: RecordingConstants.STEP_INSTALLATION_COMMAND_EXECUTION,
-            inProgressMessage: `Running: ${installCommand}`,
-            onError: (error) => {
-                Logger.error(`Error during NPM installation: ${error instanceof Error ? error.message : String(error)}`);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Install the NPM package.
-     * @param requirement The requirement to install.
-     * @param recorder Optional InstallOperationManager for recording steps.
-     * @param options Installation options.
-     * @returns The status of the installation.
-     */
-    async install(requirement, recorder, options) {
-        const targetDir = options?.settings?.folderName || this._getRequirementFolderPath(requirement);
-        await fs.mkdir(targetDir, { recursive: true });
-        return recorder.recording(async () => {
-            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);
-                    packageToInstall = result.resolvedPath;
-                    resolvedVersion = result.resolvedVersion;
-                }
-                else if (requirement.registry.artifacts) {
-                    const adoResult = await handleAdoArtifact(requirement, requirement.registry.artifacts, options?.settings?.pythonCommand, targetDir);
-                    packageToInstall = `${adoResult.package}@${adoResult.version}`;
-                    resolvedVersion = adoResult.version;
-                }
-                else {
-                    if (recorder)
-                        await recorder.recordStep('NpmInstaller:RegistryConfig', 'failed', 'Invalid registry configuration for npm.');
-                    throw new Error('Invalid registry configuration for npm.');
-                }
-            }
-            const finalInstallResult = await this._installPackage(requirement, packageToInstall, targetDir, recorder);
-            resolvedVersion = finalInstallResult.version;
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: true,
-                version: resolvedVersion,
-                inProgress: false,
-                npmPath: targetDir
-            };
-        }, {
-            stepName: RecordingConstants.STEP_NPM_INSTALLER_INSTALL,
-            inProgressMessage: `Installing npm package: ${requirement.name}`,
-            endMessage: (result) => result.installed
-                ? `Install completed for ${requirement.name}`
-                : `Install failed for ${requirement.name}`,
-            onError: (error) => {
-                return {
-                    result: {
-                        name: requirement.name,
-                        type: 'npm',
-                        installed: false,
-                        error: error instanceof Error ? error.message : String(error),
-                        inProgress: false
-                    },
-                    message: error instanceof Error ? error.message : String(error),
-                };
-            },
-        });
-    }
-}
+import{BaseInstaller}from"./BaseInstaller.js";import{compareVersions}from"../../../utils/versionUtils.js";import{handleGitHubRelease,getGitHubLatestVersion}from"../../../utils/githubUtils.js";import{handleArtifact as handleAdoArtifact,getArtifactLatestVersion}from"../../../utils/adoUtils.js";import path from"path";import fs from"fs/promises";import{SETTINGS_DIR}from"../../metadatas/constants.js";import{Logger}from"../../../utils/logger.js";import*as RecordingConstants from"../../metadatas/recordingConstants.js";export class NpmInstaller extends BaseInstaller{canHandle(e){return"npm"===e.type}supportCheckUpdates(){return!0}async getLatestVersion(e,t){if(e.registry){if(e.registry.githubRelease)return getGitHubLatestVersion(this.execPromise,e.registry.githubRelease.repository);if(e.registry.artifacts){const r=t?.settings?.folderName||this._getRequirementFolderPath(e);return getArtifactLatestVersion(e,e.registry.artifacts,t,r)}}const{stdout:r}=await this.execPromise(`npm view ${e.name} version`);return r.trim()}_getRequirementFolderPath(e){return path.join(SETTINGS_DIR,"npm_requirements",e.name,e.version.includes("latest")?"latest":e.version)}async checkInstallation(e,t){const r=t?.settings?.folderName||this._getRequirementFolderPath(e),n=this._getRequirementName(e);Logger.debug(`Checking installation for ${n} in ${r}`);try{const t=await this._getInstalledVersion(n,r);return t?{name:e.name,type:"npm",installed:!0,version:t,npmPath:r,inProgress:!1}:{name:e.name,type:"npm",installed:!1,inProgress:!1,error:`Package ${e.name} not found or version missing in npm list output in ${r}.`}}catch(t){return Logger.debug(`Error checking installation for ${e.name} in ${r}: ${t instanceof Error?t.message:String(t)}`),{name:e.name,type:"npm",installed:!1,inProgress:!1,error:t instanceof Error?t.message:String(t)}}}async _getInstalledVersion(e,t){try{const r=`npm list ${e} --depth=0 --json --prefix "${t}"`;Logger.debug(`Getting installed version for ${e} in ${t} with command: ${r}`);const{stdout:n}=await this.execPromise(r),s=JSON.parse(n);return s.dependencies&&s.dependencies[e]&&s.dependencies[e].version?s.dependencies[e].version:void Logger.debug(`Package ${e} not found in npm list output in ${t}.`)}catch(r){return void Logger.debug(`Error getting installed version for ${e} in ${t}: ${r instanceof Error?r.message:String(r)}`)}}_getRequirementName(e){return e.registry?.artifacts?.registryName?`@${e.registry.artifacts.registryName}/${e.name}`:e.name}async _installPackage(e,t,r,n){Logger.debug(`Installing NPM package from "${t}" into "${r}"`),await fs.mkdir(r,{recursive:!0});const s=`npm install ${t} --prefix "${r}"`;Logger.debug(`Executing install command: ${s}`);const i=this._getRequirementName(e);return await n.recording((async()=>{const{stdout:n,stderr:a}=await this.execPromise(s);Logger.debug(`NPM install stdout for ${t} in ${r}: ${n}`),!a||a.toLowerCase().includes("added")||a.toLowerCase().includes("updated")||a.toLowerCase().includes("found 0 vulnerabilities")||Logger.log(`NPM install stderr for ${t} in ${r}: ${a}`);const o=await this._getInstalledVersion(i,r);if(o)return Logger.log(`Successfully installed and verified ${i}@${o} into ${r}`),{version:o};throw new Error(`Successfully ran npm install for ${t}, but ${e.name} version could not be determined via npm list in ${r}, stderr: ${a}`)}),{stepName:RecordingConstants.STEP_INSTALLATION_COMMAND_EXECUTION,inProgressMessage:`Running: ${s}`,onError:e=>{throw Logger.error(`Error during NPM installation: ${e instanceof Error?e.message:String(e)}`),e}})}async install(e,t,r){const n=r?.settings?.folderName||this._getRequirementFolderPath(e);return await fs.mkdir(n,{recursive:!0}),t.recording((async()=>{const s=await this.checkInstallation(e,{settings:{folderName:n}});if(s.installed&&s.version&&0===compareVersions(s.version,e.version)&&!e.version.toLowerCase().includes("latest"))return Logger.log(`${e.name}@${s.version} already installed in ${n}.`),s;let i=e.version,a=`${e.name}@${e.version}`;if(e.registry)if(e.registry.githubRelease){const t=await handleGitHubRelease(e,e.registry.githubRelease);a=t.resolvedPath,i=t.resolvedVersion}else{if(!e.registry.artifacts)throw t&&await t.recordStep("NpmInstaller:RegistryConfig","failed","Invalid registry configuration for npm."),new Error("Invalid registry configuration for npm.");{const t=await handleAdoArtifact(e,e.registry.artifacts,r?.settings?.pythonCommand,n);a=`${t.package}@${t.version}`,i=t.version}}return i=(await this._installPackage(e,a,n,t)).version,{name:e.name,type:"npm",installed:!0,version:i,inProgress:!1,npmPath:n}}),{stepName:RecordingConstants.STEP_NPM_INSTALLER_INSTALL,inProgressMessage:`Installing npm package: ${e.name}`,endMessage:t=>t.installed?`Install completed for ${e.name}`:`Install failed for ${e.name}`,onError:t=>({result:{name:e.name,type:"npm",installed:!1,error:t instanceof Error?t.message:String(t),inProgress:!1},message:t instanceof Error?t.message:String(t)})})}}
 //# sourceMappingURL=NpmInstaller.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["BaseInstaller","compareVersions","handleGitHubRelease","getGitHubLatestVersion","handleAdoArtifact","getArtifactLatestVersion","path","fs","SETTINGS_DIR","Logger","RecordingConstants","NpmInstaller","canHandle","requirement","type","supportCheckUpdates","getLatestVersion","options","registry","githubRelease","this","execPromise","repository","artifacts","targetDir","settings","folderName","_getRequirementFolderPath","stdout","name","trim","join","version","includes","checkInstallation","requirementDir","requirementName","_getRequirementName","debug","installedVersion","_getInstalledVersion","installed","npmPath","inProgress","error","Error","message","String","directory","command","listOutput","JSON","parse","dependencies","registryName","_installPackage","packageSource","recorder","mkdir","recursive","installCommand","recording","async","installStdout","stderr","installStderr","toLowerCase","log","stepName","STEP_INSTALLATION_COMMAND_EXECUTION","inProgressMessage","onError","install","status","resolvedVersion","packageToInstall","result","resolvedPath","recordStep","adoResult","pythonCommand","package","STEP_NPM_INSTALLER_INSTALL","endMessage"],"sources":["../../../../src/core/installers/requirements/NpmInstaller.ts"],"mappings":"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","ignoreList":[]}