imcp 0.1.6 → 0.1.8-dev

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

@@ -1,189 +1,2 @@
-import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
-import { compareVersions } from '../../../utils/versionUtils.js';
-import { Logger } from '../../../utils/logger.js';
-import * as RecordingConstants from '../../metadatas/recordingConstants.js';
-import { ensureDotnetToolsInPath } from '../../../utils/osUtils.js';
-import * as fs from 'fs';
-import * as path from 'path';
-/**
- * Installer implementation for .NET packages using NuGet
- */
-export class NugetInstaller extends BaseInstaller {
-    /**
-     * Check if this installer can handle the given requirement type
-     * @param requirement The requirement to check
-     * @returns True if this installer can handle the requirement
-     */
-    canHandle(requirement) {
-        return requirement.type === 'nuget';
-    }
-    supportCheckUpdates() {
-        return true;
-    }
-    /**
-     * Get the latest version available for the NuGet package.
-     * @param requirement The requirement to check.
-     * @param _options Optional server install options (not used for NuGet).
-     * @returns The latest version string, or undefined if not found or not applicable.
-     */
-    async getLatestVersion(requirement, _options) {
-        if (requirement.registry && requirement.registry.githubRelease) {
-            return getGitHubLatestVersion(this.execPromise, requirement.registry.githubRelease.repository);
-        }
-        // Artifacts registry is not supported for nuget tools
-        if (requirement.registry && requirement.registry.artifacts) {
-            Logger.warn(`Artifacts registry is not supported for NuGet tool '${requirement.name}'.`);
-            return undefined;
-        }
-        // Default behavior: Nuget tools are often specific versions from specific sources,
-        // or global tools might not have a central "latest version" query like pip/npm.
-        // Returning current version if specified, otherwise undefined.
-        Logger.warn(`Direct latest version check for NuGet tool '${requirement.name}' without a GitHub release registry is not supported. Please specify a version or use a GitHub release.`);
-        return requirement.version || undefined;
-    }
-    /**
-     * Check if the .NET tool is already installed
-     * @param requirement The requirement to check
-     * @param _options Optional server install options (not used for NuGet)
-     * @returns The status of the requirement
-     */
-    async checkInstallation(requirement, _options) {
-        try {
-            // Command: dotnet tool list -g
-            // Output:
-            // Package Id       Version      Commands
-            // -----------------------------------------
-            // jarvistools      1.0.0        jarvistools
-            const { stdout } = await this.execPromise(`dotnet tool list -g`);
-            const lines = stdout.split('\n');
-            let installedVersion;
-            let isInstalled = false;
-            for (const line of lines) {
-                const parts = line.trim().split(/\s+/);
-                if (parts.length >= 2 && parts[0].toLowerCase() === requirement.name.toLowerCase()) {
-                    installedVersion = parts[1];
-                    isInstalled = true;
-                    break;
-                }
-            }
-            return {
-                name: requirement.name,
-                type: 'nuget',
-                installed: isInstalled,
-                version: installedVersion,
-                inProgress: false,
-            };
-        }
-        catch (error) {
-            // If 'dotnet tool list -g' fails, it might mean dotnet CLI is not properly installed or configured.
-            // Or it could mean no tools are installed, which in some dotnet versions might return non-zero exit code.
-            // We'll assume not installed in case of error, but log it.
-            Logger.debug(`Error checking NuGet tool installation for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                name: requirement.name,
-                type: 'nuget',
-                installed: false,
-                error: `Failed to check installation: ${error instanceof Error ? error.message : String(error)}`,
-                inProgress: false,
-            };
-        }
-    }
-    /**
-     * Install the .NET tool
-     * @param requirement The requirement to install
-     * @param recorder Optional InstallOperationManager for recording steps
-     * @param _options Optional server install options (not used for NuGet)
-     * @returns The status of the installation
-     */
-    async install(requirement, recorder, _options) {
-        return await recorder.recording(async () => {
-            const status = await this.checkInstallation(requirement, _options);
-            if (status.installed && status.version && requirement.version &&
-                compareVersions(status.version, requirement.version) === 0 &&
-                !requirement.version.toLowerCase().includes('latest')) {
-                Logger.log(`NuGet tool ${requirement.name}==${status.version} already installed.`);
-                return status;
-            }
-            let command;
-            if (requirement.registry && requirement.registry.githubRelease) {
-                const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                // Nuget package name might be different from the requirement name if alias is used.
-                // However, dotnet tool install uses the package ID from the nupkg.
-                // We assume requirement.name is the package ID.
-                const packageId = requirement.name;
-                const resolvedDir = fs.existsSync(result.resolvedPath) && fs.lstatSync(result.resolvedPath).isDirectory() ? result.resolvedPath : path.dirname(result.resolvedPath);
-                if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
-                    command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId} --version ${requirement.version}`;
-                }
-                else {
-                    // Install latest from the source
-                    command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId}`;
-                }
-            }
-            else if (requirement.registry && requirement.registry.artifacts) {
-                const errorMessage = `Artifacts registry is not supported for NuGet tool yet'${requirement.name}'. Only GitHubRelease is supported.`;
-                Logger.error(errorMessage);
-                await recorder.recordStep('NugetInstaller:RegistryConfig', 'failed', errorMessage);
-                throw new Error(errorMessage);
-            }
-            else {
-                // Default installation from nuget.org or configured feeds
-                if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
-                    command = `dotnet tool install --global ${requirement.name} --version ${requirement.version}`;
-                }
-                else {
-                    command = `dotnet tool install --global ${requirement.name}`;
-                }
-            }
-            return await recorder.recording(async () => {
-                const { stdout, stderr } = await this.execPromise(command);
-                if (stderr && !stdout.toLowerCase().includes('already installed')) { // Some warnings might go to stderr
-                    Logger.debug(`NuGet tool installation stderr for ${requirement.name}: ${stderr}`);
-                    // Check if it was actually an error or just a warning
-                    const checkStatus = await this.checkInstallation(requirement, _options);
-                    if (!checkStatus.installed) {
-                        Logger.error(`NuGet tool ${requirement.name} not found after install command, stderr: ${stderr}`);
-                        throw new Error(`NuGet tool installation failed with: ${stderr}`);
-                    }
-                }
-                const finalStatus = await this.checkInstallation(requirement, _options);
-                if (!finalStatus.installed) {
-                    throw new Error(`NuGet tool ${requirement.name} failed to install. Please check logs.`);
-                }
-                // After successful installation, ensure .NET tools path is in system PATH
-                await ensureDotnetToolsInPath();
-                return {
-                    name: requirement.name,
-                    type: 'nuget',
-                    installed: true,
-                    version: finalStatus.version || requirement.version, // Use checked version if available
-                    inProgress: false,
-                };
-            }, {
-                stepName: `${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${requirement.name} : ${requirement.version || 'latest'}`,
-                inProgressMessage: `Running: ${command}`,
-                endMessage: (result) => result.installed ? `Succeeded: ${command}` : `Failed: ${command}`,
-            });
-        }, {
-            stepName: RecordingConstants.STEP_NUGET_INSTALLER_INSTALL,
-            inProgressMessage: `Installing NuGet tool: ${requirement.name}`,
-            endMessage: (result) => result.installed
-                ? `Install completed for ${requirement.name} with version ${result.version}`
-                : `Install failed for ${requirement.name}`,
-            onError: (error) => {
-                return {
-                    result: {
-                        name: requirement.name,
-                        type: 'nuget',
-                        installed: false,
-                        error: error instanceof Error ? error.message : String(error),
-                        inProgress: false,
-                    },
-                    message: error instanceof Error ? error.message : String(error),
-                };
-            },
-        });
-    }
-}
+import{BaseInstaller}from"./BaseInstaller.js";import{handleGitHubRelease,getGitHubLatestVersion}from"../../../utils/githubUtils.js";import{compareVersions}from"../../../utils/versionUtils.js";import{Logger}from"../../../utils/logger.js";import*as RecordingConstants from"../../metadatas/recordingConstants.js";import{ensureDotnetToolsInPath}from"../../../utils/osUtils.js";import*as fs from"fs";import*as path from"path";export class NugetInstaller extends BaseInstaller{canHandle(e){return"nuget"===e.type}supportCheckUpdates(){return!0}async getLatestVersion(e,t){return e.registry&&e.registry.githubRelease?getGitHubLatestVersion(this.execPromise,e.registry.githubRelease.repository):e.registry&&e.registry.artifacts?void Logger.warn(`Artifacts registry is not supported for NuGet tool '${e.name}'.`):(Logger.warn(`Direct latest version check for NuGet tool '${e.name}' without a GitHub release registry is not supported. Please specify a version or use a GitHub release.`),e.version||void 0)}async checkInstallation(e,t){try{const{stdout:t}=await this.execPromise("dotnet tool list -g"),s=t.split("\n");let r,o=!1;for(const t of s){const s=t.trim().split(/\s+/);if(s.length>=2&&s[0].toLowerCase()===e.name.toLowerCase()){r=s[1],o=!0;break}}return{name:e.name,type:"nuget",installed:o,version:r,inProgress:!1}}catch(t){return Logger.debug(`Error checking NuGet tool installation for ${e.name}: ${t instanceof Error?t.message:String(t)}`),{name:e.name,type:"nuget",installed:!1,error:`Failed to check installation: ${t instanceof Error?t.message:String(t)}`,inProgress:!1}}}async install(e,t,s){return await t.recording((async()=>{const r=await this.checkInstallation(e,s);if(r.installed&&r.version&&e.version&&0===compareVersions(r.version,e.version)&&!e.version.toLowerCase().includes("latest"))return Logger.log(`NuGet tool ${e.name}==${r.version} already installed.`),r;let o;if(e.registry&&e.registry.githubRelease){const t=await handleGitHubRelease(e,e.registry.githubRelease),s=e.name,r=fs.existsSync(t.resolvedPath)&&fs.lstatSync(t.resolvedPath).isDirectory()?t.resolvedPath:path.dirname(t.resolvedPath);o=e.version&&!e.version.toLowerCase().includes("latest")?`dotnet tool install --global --add-source "${r}" ${s} --version ${e.version}`:`dotnet tool install --global --add-source "${r}" ${s}`}else{if(e.registry&&e.registry.artifacts){const s=`Artifacts registry is not supported for NuGet tool yet'${e.name}'. Only GitHubRelease is supported.`;throw Logger.error(s),await t.recordStep("NugetInstaller:RegistryConfig","failed",s),new Error(s)}o=e.version&&!e.version.toLowerCase().includes("latest")?`dotnet tool install --global ${e.name} --version ${e.version}`:`dotnet tool install --global ${e.name}`}return await t.recording((async()=>{const{stdout:t,stderr:r}=await this.execPromise(o);if(r&&!t.toLowerCase().includes("already installed")&&(Logger.debug(`NuGet tool installation stderr for ${e.name}: ${r}`),!(await this.checkInstallation(e,s)).installed))throw Logger.error(`NuGet tool ${e.name} not found after install command, stderr: ${r}`),new Error(`NuGet tool installation failed with: ${r}`);const n=await this.checkInstallation(e,s);if(!n.installed)throw new Error(`NuGet tool ${e.name} failed to install. Please check logs.`);return await ensureDotnetToolsInPath(),{name:e.name,type:"nuget",installed:!0,version:n.version||e.version,inProgress:!1}}),{stepName:`${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${e.name} : ${e.version||"latest"}`,inProgressMessage:`Running: ${o}`,endMessage:e=>e.installed?`Succeeded: ${o}`:`Failed: ${o}`})}),{stepName:RecordingConstants.STEP_NUGET_INSTALLER_INSTALL,inProgressMessage:`Installing NuGet tool: ${e.name}`,endMessage:t=>t.installed?`Install completed for ${e.name} with version ${t.version}`:`Install failed for ${e.name}`,onError:t=>({result:{name:e.name,type:"nuget",installed:!1,error:t instanceof Error?t.message:String(t),inProgress:!1},message:t instanceof Error?t.message:String(t)})})}}
 //# sourceMappingURL=NugetInstaller.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["BaseInstaller","handleGitHubRelease","getGitHubLatestVersion","compareVersions","Logger","RecordingConstants","ensureDotnetToolsInPath","fs","path","NugetInstaller","canHandle","requirement","type","supportCheckUpdates","getLatestVersion","_options","registry","githubRelease","this","execPromise","repository","artifacts","warn","name","version","undefined","checkInstallation","stdout","lines","split","installedVersion","isInstalled","line","parts","trim","length","toLowerCase","installed","inProgress","error","debug","Error","message","String","install","recorder","recording","async","status","includes","log","command","result","packageId","resolvedDir","existsSync","resolvedPath","lstatSync","isDirectory","dirname","errorMessage","recordStep","stderr","finalStatus","stepName","STEP_INSTALL_COMMAND_PREFIX","inProgressMessage","endMessage","STEP_NUGET_INSTALLER_INSTALL","onError"],"sources":["../../../../src/core/installers/requirements/NugetInstaller.ts"],"mappings":"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","ignoreList":[]}

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

@@ -1,193 +1,2 @@
-import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
-import { handleArtifact as handleAdoArtifact, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
-import { compareVersions } from '../../../utils/versionUtils.js';
-import { Logger } from '../../../utils/logger.js';
-import * as RecordingConstants from '../../metadatas/recordingConstants.js';
-/**
- * Installer implementation for Python packages using pip
- */
-export class PipInstaller extends BaseInstaller {
-    getPythonCommand(options) {
-        return options?.settings?.pythonEnv || 'python';
-    }
-    getPipCommand(options) {
-        const pythonCmd = this.getPythonCommand(options);
-        return `${pythonCmd} -m pip`;
-    }
-    /**
-     * Check if this installer can handle the given requirement type
-     * @param requirement The requirement to check
-     * @returns True if this installer can handle the requirement
-     */
-    canHandle(requirement) {
-        return requirement.type === 'pip';
-    }
-    supportCheckUpdates() {
-        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, 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
-                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, options) {
-        try {
-            const pipCmd = this.getPipCommand(options);
-            const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
-            const installed = stdout.includes(requirement.name.toLowerCase());
-            const versionMatch = stdout.match(/Version: (.+)/);
-            const installedVersion = versionMatch ? versionMatch[1] : undefined;
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: installed,
-                version: installedVersion,
-                inProgress: false,
-                pythonEnv: this.getPythonCommand(options)
-            };
-        }
-        catch (error) {
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false,
-                pythonEnv: this.getPythonCommand(options)
-            };
-        }
-    }
-    /**
-     * Install the Python package
-     * @param requirement The requirement to install
-     * @param recorder Optional InstallOperationManager for recording steps
-     * @param options Optional server install options
-     * @returns The status of the installation
-     */
-    async install(requirement, recorder, options) {
-        return await recorder.recording(async () => {
-            const status = await this.checkInstallation(requirement, options);
-            if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0 && !requirement.version.toLowerCase().includes('latest')) {
-                Logger.log(`${requirement.name}==${status.version} already installed for ${this.getPythonCommand}.`);
-                return status;
-            }
-            const pipCmd = this.getPipCommand(options);
-            let command;
-            if (!requirement.registry) {
-                if (requirement.version && !requirement.version.includes('latest')) {
-                    command = `${pipCmd} install ${requirement.name}==${requirement.version}`;
-                }
-                else {
-                    command = `${pipCmd} install --upgrade ${requirement.name}`;
-                }
-            }
-            else {
-                let packageSource;
-                if (requirement.registry.githubRelease) {
-                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                    packageSource = result.resolvedPath;
-                    command = `${pipCmd} install "${packageSource}"`;
-                }
-                else if (requirement.registry.artifacts) {
-                    const pythonCmd = this.getPythonCommand(options);
-                    const adoArtifactResult = await handleAdoArtifact(requirement, requirement.registry.artifacts, pythonCmd);
-                    command = `${pipCmd} install ${adoArtifactResult.package} --extra-index-url ${adoArtifactResult.registryUrl}`;
-                }
-                else {
-                    await recorder.recordStep('PipInstaller:RegistryConfig', 'failed', 'Invalid registry configuration');
-                    throw new Error('Invalid registry configuration');
-                }
-            }
-            return await recorder.recording(async () => {
-                const { stderr } = await this.execPromise(command);
-                if (stderr && stderr.toLowerCase().includes('error')) {
-                    Logger.debug(`Pip installation error: ${stderr}`);
-                    // wait for 5 seconds as python pip would be little delayed
-                    await new Promise(resolve => setTimeout(resolve, 5000));
-                    const checkStatus = await this.checkInstallation(requirement, options);
-                    if (!checkStatus.installed) {
-                        Logger.error(`Package not found after the command, ${stderr}`);
-                        throw new Error(`Pip installation failed with: ${stderr}`);
-                    }
-                }
-                return {
-                    name: requirement.name,
-                    type: 'pip',
-                    installed: true,
-                    version: requirement.version, // This might need to be updated to actual installed version
-                    inProgress: false,
-                    pythonEnv: this.getPythonCommand(options)
-                };
-            }, {
-                stepName: `${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${requirement.name} : ${requirement.version}`,
-                inProgressMessage: `Running: ${command}`,
-                endMessage: (result) => result.installed ? `Succeeded: ${command}` : `Failed: ${command}`,
-            });
-        }, {
-            stepName: RecordingConstants.STEP_PIP_INSTALLER_INSTALL,
-            inProgressMessage: `Installing pip package: ${requirement.name}`,
-            endMessage: (result) => result.installed
-                ? `Install completed for ${requirement.name} with version ${result.version}`
-                : `Install failed for ${requirement.name}`,
-            onError: (error) => {
-                return {
-                    result: {
-                        name: requirement.name,
-                        type: 'pip',
-                        installed: false,
-                        error: error instanceof Error ? error.message : String(error),
-                        inProgress: false,
-                        pythonEnv: this.getPythonCommand(options)
-                    },
-                    message: error instanceof Error ? error.message : String(error),
-                };
-            },
-        });
-    }
-}
+import{BaseInstaller}from"./BaseInstaller.js";import{handleGitHubRelease,getGitHubLatestVersion}from"../../../utils/githubUtils.js";import{handleArtifact as handleAdoArtifact,getArtifactLatestVersion}from"../../../utils/adoUtils.js";import{compareVersions}from"../../../utils/versionUtils.js";import{Logger}from"../../../utils/logger.js";import*as RecordingConstants from"../../metadatas/recordingConstants.js";export class PipInstaller extends BaseInstaller{getPythonCommand(e){return e?.settings?.pythonEnv||"python"}getPipCommand(e){return`${this.getPythonCommand(e)} -m pip`}canHandle(e){return"pip"===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)return getArtifactLatestVersion(e,e.registry.artifacts,t)}const s=this.getPipCommand(t),{stdout:r}=await this.execPromise(`${s} index versions ${e.name} --pre=0`),n=r.match(/(?:LATEST|Latest):\s*([^\s]+)/);if(n&&n[1])return n[1];const i=r.match(/(?:Available versions|VERSIONS):\s*([^\n]+)/);if(i&&i[1]){const e=i[1].split(",").map((e=>e.trim()));if(e.length>0)return e[0]}}async checkInstallation(e,t){try{const s=this.getPipCommand(t),{stdout:r,stderr:n}=await this.execPromise(`${s} show ${e.name}`),i=r.includes(e.name.toLowerCase()),a=r.match(/Version: (.+)/),o=a?a[1]:void 0;return{name:e.name,type:"pip",installed:i,version:o,inProgress:!1,pythonEnv:this.getPythonCommand(t)}}catch(s){return{name:e.name,type:"pip",installed:!1,error:s instanceof Error?s.message:String(s),inProgress:!1,pythonEnv:this.getPythonCommand(t)}}}async install(e,t,s){return await t.recording((async()=>{const r=await this.checkInstallation(e,s);if(r.installed&&r.version&&0===compareVersions(r.version,e.version)&&!e.version.toLowerCase().includes("latest"))return Logger.log(`${e.name}==${r.version} already installed for ${this.getPythonCommand}.`),r;const n=this.getPipCommand(s);let i;if(e.registry){let r;if(e.registry.githubRelease)r=(await handleGitHubRelease(e,e.registry.githubRelease)).resolvedPath,i=`${n} install "${r}"`;else{if(!e.registry.artifacts)throw await t.recordStep("PipInstaller:RegistryConfig","failed","Invalid registry configuration"),new Error("Invalid registry configuration");{const t=this.getPythonCommand(s),r=await handleAdoArtifact(e,e.registry.artifacts,t);i=`${n} install ${r.package} --extra-index-url ${r.registryUrl}`}}}else i=e.version&&!e.version.includes("latest")?`${n} install ${e.name}==${e.version}`:`${n} install --upgrade ${e.name}`;return await t.recording((async()=>{const{stderr:t}=await this.execPromise(i);if(t&&t.toLowerCase().includes("error")&&(Logger.debug(`Pip installation error: ${t}`),await new Promise((e=>setTimeout(e,5e3))),!(await this.checkInstallation(e,s)).installed))throw Logger.error(`Package not found after the command, ${t}`),new Error(`Pip installation failed with: ${t}`);return{name:e.name,type:"pip",installed:!0,version:e.version,inProgress:!1,pythonEnv:this.getPythonCommand(s)}}),{stepName:`${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${e.name} : ${e.version}`,inProgressMessage:`Running: ${i}`,endMessage:e=>e.installed?`Succeeded: ${i}`:`Failed: ${i}`})}),{stepName:RecordingConstants.STEP_PIP_INSTALLER_INSTALL,inProgressMessage:`Installing pip package: ${e.name}`,endMessage:t=>t.installed?`Install completed for ${e.name} with version ${t.version}`:`Install failed for ${e.name}`,onError:t=>({result:{name:e.name,type:"pip",installed:!1,error:t instanceof Error?t.message:String(t),inProgress:!1,pythonEnv:this.getPythonCommand(s)},message:t instanceof Error?t.message:String(t)})})}}
 //# sourceMappingURL=PipInstaller.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["BaseInstaller","handleGitHubRelease","getGitHubLatestVersion","handleAdoArtifact","getArtifactLatestVersion","compareVersions","Logger","RecordingConstants","PipInstaller","getPythonCommand","options","settings","pythonEnv","getPipCommand","this","canHandle","requirement","type","supportCheckUpdates","getLatestVersion","registry","githubRelease","execPromise","repository","artifacts","pipCmd","stdout","name","latestMatch","match","versionsMatch","versions","split","map","v","trim","length","checkInstallation","stderr","installed","includes","toLowerCase","versionMatch","installedVersion","undefined","version","inProgress","error","Error","message","String","install","recorder","recording","async","status","log","command","packageSource","resolvedPath","recordStep","pythonCmd","adoArtifactResult","package","registryUrl","debug","Promise","resolve","setTimeout","stepName","STEP_INSTALL_COMMAND_PREFIX","inProgressMessage","endMessage","result","STEP_PIP_INSTALLER_INSTALL","onError"],"sources":["../../../../src/core/installers/requirements/PipInstaller.ts"],"mappings":"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","ignoreList":[]}

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

@@ -1,3 +1,2 @@
-export {};
-// Note: Do not re-export implementations from here to avoid circular dependencies
+export{};
 //# sourceMappingURL=RequirementInstaller.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":[],"mappings":"","ignoreList":[]}