imcp 0.0.14 → 0.0.16

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

@@ -1,5 +1,9 @@
 import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
+// Assuming getArtifactLatestVersion will be available in adoUtils.ts
+import { handleArtifact as handleAdoArtifact, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { Logger } from '../../../utils/logger.js';
 /**
  * Installer implementation for Python packages using pip
  */
@@ -20,29 +24,71 @@ export class PipInstaller extends BaseInstaller {
         return requirement.type === 'pip';
     }
     supportCheckUpdates() {
-        /// temporarily disabling update check for pip as not able to get which pip of python is being used
         return true;
     }
+    /**
+     * Get the latest version available for the pip package.
+     * @param requirement The requirement to check.
+     * @param options Optional server install options.
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    async getLatestVersion(requirement, 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}`);
-            // If we get an output and no error, the package is installed
-            const installed = stdout.includes(requirement.name);
+            const installed = stdout.includes(requirement.name.toLowerCase());
             const versionMatch = stdout.match(/Version: (.+)/);
             const installedVersion = versionMatch ? versionMatch[1] : undefined;
             return {
                 name: requirement.name,
                 type: 'pip',
-                installed,
+                installed: installed,
                 version: installedVersion,
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv in status check too
+                pythonEnv: this.getPythonCommand(options)
             };
         }
         catch (error) {
@@ -52,70 +98,62 @@ export class PipInstaller extends BaseInstaller {
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv even in error case
+                pythonEnv: this.getPythonCommand(options)
             };
         }
     }
     /**
      * Install the Python package
      * @param requirement The requirement to install
+     * @param options Optional server install options
      * @returns The status of the installation
      */
     async install(requirement, options) {
         try {
             const status = await this.checkInstallation(requirement, options);
-            if (status.installed) {
+            if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0 && !requirement.version.toLowerCase().includes('latest')) {
+                Logger.log(`${requirement.name}==${status.version} already installed for ${this.getPythonCommand}.`);
                 return status;
             }
             const pipCmd = this.getPipCommand(options);
-            // If no registry is specified, use standard pip installation
             if (!requirement.registry) {
-                // Standard pip installation
                 const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
                 if (stderr && stderr.toLowerCase().includes('error')) {
                     throw new Error(stderr);
                 }
             }
             else {
-                // Handle different registry types
                 let packageSource;
                 if (requirement.registry.githubRelease) {
                     const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
                     packageSource = result.resolvedPath;
-                    // Install from the downloaded wheel or tar.gz file
                     const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }
                 }
                 else if (requirement.registry.artifacts) {
-                    const registryUrl = requirement.registry.artifacts.registryUrl;
-                    // Install using the custom index URL
-                    const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`);
+                    const pythonCmd = this.getPythonCommand(options);
+                    const adoArtifactResult = await handleAdoArtifact(requirement, requirement.registry.artifacts, pythonCmd);
+                    const { stderr } = await this.execPromise(`${pipCmd} install ${adoArtifactResult.package} --extra-index-url ${adoArtifactResult.registryUrl}`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
-                    }
-                }
-                else if (requirement.registry.local) {
-                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
-                    // Install from the local path
-                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
+                        const checkStatus = await this.checkInstallation(requirement, options);
+                        if (!checkStatus.installed) {
+                            throw new Error(`Pip installation failed with: ${stderr}`);
+                        }
                     }
                 }
                 else {
                     throw new Error('Invalid registry configuration');
                 }
             }
-            // Store the pythonEnv in the status for future use
             return {
                 name: requirement.name,
                 type: 'pip',
                 installed: true,
-                version: requirement.version,
+                version: requirement.version, // This might need to be updated to actual installed version
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Store the python env
+                pythonEnv: this.getPythonCommand(options)
             };
         }
         catch (error) {
@@ -125,7 +163,7 @@ export class PipInstaller extends BaseInstaller {
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
                 inProgress: false,
-                pythonEnv: this.getPythonCommand(options) // Store the python env
+                pythonEnv: this.getPythonCommand(options)
             };
         }
     }

package/dist/core/onboard/FeedOnboardService.d.ts

@@ -1,35 +1,72 @@
 import { FeedConfiguration } from '../types.js';
+import { OperationStatus } from './OnboardStatus.js';
 /**
  * Service for handling feed onboarding operations
  */
 export declare class FeedOnboardService {
-    private tempDir;
-    private repoDir;
     constructor();
     /**
      * Onboard a new feed configuration
      * @param config Feed configuration to onboard
      */
-    onboardFeed(config: FeedConfiguration): Promise<void>;
+    onboardFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
+        feedConfiguration?: FeedConfiguration;
+    }>;
     /**
-     * Fork the repository using gh CLI
+     * Validate a feed configuration without performing full onboarding
+     * @param config Feed configuration to validate
+     * @returns Operation status indicating the result of the validation initiation
      */
-    private forkRepo;
+    validateFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
+        feedConfiguration?: FeedConfiguration;
+    }>;
     /**
-     * Clone the forked repository
+     * Initiates either a full onboarding or a validation-only operation.
+     * It checks for existing non-completed operations for the same feed and operation type.
+     * If an existing operation is found, its status is returned. Otherwise, a new operation is created and started.
+     * @param config The feed configuration.
+     * @param operationType The type of operation to initiate (FULL_ONBOARDING or VALIDATION_ONLY).
+     * @returns A promise that resolves to the operation status.
      */
-    private cloneRepo;
+    private _initiateOperation;
     /**
-     * Get GitHub username using gh CLI
+     * Finds an existing non-completed operation for a given feed name, server name, and operation type.
+     * @param feedName The name of the feed.
+     * @param operationType The type of operation.
+     * @returns A promise that resolves to the OnboardStatus of the existing operation, or undefined if not found.
      */
-    private getGitHubUsername;
+    private _findExistingNonCompletedOperation;
     /**
-     * Save feed configuration to file
+     * Performs static validation of the feed configuration.
+     * @param config The feed configuration to validate.
+     * @param forExistingCategory Whether this is for an existing category.
+     * @throws Error if validation fails.
      */
-    private saveFeedConfig;
+    private validateStaticConfig;
     /**
-     * Create pull request using gh CLI
+     * Validates the feed configuration.
+     * Updates the onboarding status to VALIDATING, then to VALIDATED or FAILED based on the validation result.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration to validate.
+     * @throws Error if validation fails, to be caught by the calling process.
      */
-    private createPullRequest;
+    private _validateFeedConfiguration;
+    /**
+     * Processes a validation-only operation for a feed configuration.
+     * It validates the configuration and updates the status to SUCCEEDED if validation is successful.
+     * If validation fails, the error is handled by _validateFeedConfiguration and the calling _initiateOperation method.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     */
+    private processValidationOnly;
+    /**
+     * Processes the full onboarding for a feed configuration.
+     * This includes validation, forking/cloning the repository, saving the config, and creating a pull request.
+     * Manages status updates throughout the process and handles cleanup of temporary directories.
+     * @param onboardingId The ID of the onboarding process.
+     * @param config The feed configuration.
+     * @throws Error if any step of the full onboarding process fails.
+     */
+    private processFullOnboarding;
 }
 export declare const feedOnboardService: FeedOnboardService;