imcp 0.0.13 → 0.0.15

package/src/core/validators/StdioServerValidator.ts

@@ -0,0 +1,259 @@
+import { McpConfig, RequirementConfig, FeedConfiguration } from "../types.js";
+import { IServerValidator } from "./IServerValidator.js";
+import { Logger } from "../../utils/logger.js";
+import { createInstallerFactory } from "../installers/index.js";
+import { exec, spawn } from 'child_process';
+import util from 'util';
+import { MACRO_EXPRESSIONS, resolveNpmModulePath } from "../../utils/macroExpressionUtils.js";
+import { getSystemPythonPackageDirectory } from "../../utils/osUtils.js";
+import { SETTINGS_DIR } from "../constants.js";
+import path from "path";
+
+const execPromise = util.promisify(exec);
+
+/**
+ * Validates MCP server configurations for stdio mode
+ */
+export class StdioServerValidator implements IServerValidator {
+  private installerFactory = createInstallerFactory();
+
+  /**
+   * Tests if a command exists and is executable
+   * @param command The command to test
+   * @returns true if command exists and is executable
+   */
+  private async isCommandExecutable(command: string): Promise<boolean> {
+    try {
+      Logger.debug(`Testing if command is executable: ${command}`);
+      const testCmd = process.platform === 'win32' ?
+        `where ${command}` :
+        `command -v ${command}`;
+
+      await execPromise(testCmd);
+      return true;
+    } catch (error) {
+      Logger.debug(`Command not found: ${command}`);
+      return false;
+    }
+  }
+
+  /**
+   * Generates a dedicated folder path for a requirement.
+   * @param requirement The requirement configuration.
+   * @returns The path to the requirement's dedicated folder.
+   * @private
+   */
+  private _getRequirementFolderPath(requirement: RequirementConfig): string {
+    return path.join(
+      SETTINGS_DIR,
+      'onboard',
+      'npm_requirements',
+      requirement.name,
+      requirement.version.includes('latest') ? 'latest' : requirement.version);
+  }
+
+  /**
+   * Validates and installs a requirement if needed
+   * @param requirement The requirement config to validate and install
+   * @returns true if requirement is successfully installed/validated
+   */
+  private async validateRequirement(requirement: RequirementConfig): Promise<boolean> {
+    try {
+      Logger.debug(`Validating/installing requirement: ${requirement.name}`);
+      const installer = this.installerFactory.getInstaller(requirement);
+
+      if (!installer) {
+        const msg = `No installer found for requirement type: ${requirement.type}`;
+        Logger.error(msg);
+        throw new Error(msg);
+      }
+
+      const targetDir = this._getRequirementFolderPath(requirement);
+      const status = await installer.install(requirement, { settings: { folderName: targetDir } });
+      if (!status.installed) {
+        const msg = `Failed to install requirement ${requirement.name}: ${status.error || 'Unknown error'}`;
+        Logger.error(msg);
+        throw new Error(msg);
+      }
+
+      Logger.debug(`Requirement ${requirement.name} is valid and installed`);
+      return true;
+    } catch (error) {
+      const errorMsg = `Error validating/installing requirement ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`;
+      Logger.error(errorMsg);
+      throw error instanceof Error ? error : new Error(errorMsg);
+    }
+  }
+
+  /**
+   * Tests if a server can be started successfully with proper path resolution
+   * @param command The command to start the server
+   * @param args The command line arguments
+   * @returns Promise<boolean> true if server starts successfully, false otherwise
+   * 
+   * Handles special cases:
+   * - For node commands: resolves ${NPMPATH} in arguments using resolveNpmModulePath
+   * - For python/python3 commands: resolves ${PYTHON_PACKAGE} in arguments using system Python packages
+   */
+  private async testServerStartup(command: string, args: string[], requirement?: RequirementConfig): Promise<boolean> {
+    try {
+      // Log initial command and args
+      Logger.debug(`Testing server startup with command: ${command}`);
+      Logger.debug(`Original arguments: ${args.join(' ')}`);
+
+      // Handle path resolution based on command type
+      let finalArgs = [...args];
+
+      if (command === 'node') {
+        // Resolve npm module paths in arguments
+        Logger.debug('Resolving npm module paths in arguments');
+        const npmPath = requirement ? this._getRequirementFolderPath(requirement) : undefined;
+        finalArgs = args.map(arg => arg.replace(MACRO_EXPRESSIONS.NPMPATH, resolveNpmModulePath(npmPath)));
+        Logger.debug(`Resolved npm arguments: ${finalArgs.join(' ')}`);
+      } else if (command === 'python' || command === 'python3') {
+        // Resolve Python package paths in arguments
+        Logger.debug('Resolving Python package paths in arguments');
+        const pythonDir = await getSystemPythonPackageDirectory();
+        if (pythonDir) {
+          finalArgs = args.map(arg => arg.includes('${PYTHON_PACKAGE}') ? arg.replace('${PYTHON_PACKAGE}', pythonDir) : arg);
+          Logger.debug(`Resolved Python arguments: ${finalArgs.join(' ')}`);
+        } else {
+          const msg = 'Could not resolve system Python package directory';
+          Logger.error(msg);
+          throw new Error(msg);
+        }
+      }
+
+      return await new Promise<boolean>((resolve, reject) => {
+        Logger.debug(`Starting process with command: ${command} ${finalArgs.join(' ')}`);
+
+        // Set timeout for server startup test
+        const timeout = setTimeout(() => {
+          const msg = 'Server startup test timed out after 10 seconds';
+          Logger.error(msg);
+          serverProcess.kill();
+          reject(new Error(msg));
+        }, 20000);
+
+        // Start the server process
+        const serverProcess = spawn(command, finalArgs, {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          shell: true
+        });
+
+        let output = '';
+        let errorOutput = '';
+
+        // Collect stdout
+        serverProcess.stdout.on('data', (data: Buffer) => {
+          output += data.toString();
+          // If we see any output, consider it a success
+          clearTimeout(timeout);
+          serverProcess.kill();
+          resolve(true);
+        });
+
+        // Collect stderr
+        serverProcess.stderr.on('data', (data: Buffer) => {
+          errorOutput += data.toString();
+        });
+
+        // Handle process exit
+        serverProcess.on('exit', (code: number | null) => {
+          clearTimeout(timeout);
+          if (code !== null && code !== 0) {
+            const msg = `Server startup failed with code ${code}: ${errorOutput}`;
+            Logger.error(msg);
+            reject(new Error(msg));
+          }
+        });
+
+        // Handle process error
+        serverProcess.on('error', (error: Error) => {
+          clearTimeout(timeout);
+          const msg = `Server startup error: ${error.message}`;
+          Logger.error(msg);
+          reject(error);
+        });
+      });
+    } catch (error) {
+      const msg = `Failed to test server startup: ${error instanceof Error ? error.message : String(error)}`;
+      Logger.error(msg);
+      throw error instanceof Error ? error : new Error(msg);
+    }
+  }
+
+  /**
+   * Validates stdio-specific MCP server configuration
+   * Checks command, arguments, dependencies and required environment variables
+   * @param server The MCP server configuration to validate
+   * @param config The feed configuration containing shared requirements
+   * @returns true if valid, throws error if invalid
+   */
+  public async validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean> {
+    try {
+      Logger.debug(`Validating stdio server configuration: ${server.name}`);
+
+      // Check required installation command
+      if (!server.installation?.command) {
+        throw new Error('Server command is required in installation configuration');
+      }
+
+      // Validate server mode
+      if (server.mode !== 'stdio') {
+        throw new Error(`Invalid server mode for stdio validator: ${server.mode}`);
+      }
+
+      // Parse command and arguments
+      const fullCommand = server.installation.command;
+      const [baseCommand, ...defaultArgs] = fullCommand.split(' ');
+      const args = [...defaultArgs, ...(server.installation.args || [])];
+
+      // Validate command exists and is executable
+      const isExecutable = await this.isCommandExecutable(baseCommand);
+      if (!isExecutable) {
+        throw new Error(`Command not found or not executable: ${baseCommand}`);
+      }
+
+      // Validate required environment variables if specified
+      const envVars = server.installation.env;
+      if (envVars) {
+        for (const [name, varConfig] of Object.entries(envVars)) {
+          if (varConfig.Required && !varConfig.Default && !process.env[name]) {
+            throw new Error(`Required environment variable not set: ${name}`);
+          }
+        }
+      }
+
+      // Validate dependencies if specified
+      if (server.dependencies?.requirements) {
+        Logger.debug(`Validating ${server.dependencies.requirements.length} requirements`);
+
+        for (const req of server.dependencies.requirements) {
+          const reqConfig: RequirementConfig = config.requirements?.find(r => r.name === req.name) || {
+            name: req.name,
+            version: req.version,
+            type: 'npm' // Default to npm if not specified
+          };
+
+          const isValid = await this.validateRequirement(reqConfig);
+          if (!isValid) {
+            throw new Error(`Dependency validation failed for: ${req.name}`);
+          }
+        }
+      }
+      // Test server startup
+      const serverStarted = await this.testServerStartup(baseCommand, args, config.requirements?.find(r => r.type === 'npm'));
+      if (!serverStarted) {
+        throw new Error(`Failed to start server with command: ${fullCommand} ${args.join(' ')}`);
+      }
+
+      Logger.debug(`Stdio server validation successful: ${server.name}`);
+      return true;
+    } catch (error) {
+      const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
+      Logger.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+  }
+}

package/src/services/InstallRequestValidator.ts

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { FeedConfiguration, EnvVariableConfig, ServerInstallOptions } from '../core/types.js';
-import { InstallServersRequestBody } from '../web/server.js'; // Assuming InstallRequestBody is defined here
+import { InstallServersRequestBody } from '../web/contract/serverContract.js'; // Assuming InstallRequestBody is defined here
 import { SUPPORTED_CLIENT_NAMES } from '../core/constants.js';
 
 export class InstallRequestValidator {

package/src/services/ServerService.ts

@@ -7,9 +7,12 @@ import {
   ServerInstallOptions,
   ServerCategoryListOptions,
   ServerOperationResult,
-  ServerUninstallOptions
+  ServerUninstallOptions,
+  FeedConfiguration,
+  OperationStatus as CoreOperationStatus
 } from '../core/types.js';
 import { mcpManager } from '../core/MCPManager.js';
+import { OperationStatus } from '../core/onboard/OnboardStatus.js';
 import { UPDATE_CHECK_INTERVAL_MS } from '../core/constants.js';
 import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
 
@@ -140,12 +143,11 @@ export class ServerService {
 
   /**
    * Installs a specific mcp tool for a server.
-   * TODO: This might require enhancing MCPManager to handle category-specific installs.
    */
   async installMcpServer(
     category: string,
     serverName: string,
-    options: ServerInstallOptions = {} // Reuse ServerInstallOptions for env etc.
+    options: ServerInstallOptions = {}
   ): Promise<ServerOperationResult> {
     Logger.debug(`Installing MCP server: ${JSON.stringify({ category, serverName, options })}`);
     try {
@@ -158,10 +160,6 @@ export class ServerService {
     }
   }
 
-  /**
-   * Installs a specific mcp tool for a server.
-   * TODO: This might require enhancing MCPManager to handle category-specific installs.
-   */
   /**
    * Uninstall MCP server from specified client targets
    * @param category The server category
@@ -230,6 +228,23 @@ export class ServerService {
   async syncFeeds(): Promise<void> {
     return mcpManager.syncFeeds();
   }
+
+  /**
+   * Onboards a new feed configuration
+   * @param config Feed configuration to onboard
+   */
+  async onboardFeed(config: FeedConfiguration): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
+    try {
+      const result = await mcpManager.onboardFeed(config);
+      // Log based on the operation status, e.g., if it's pending or succeeded.
+      // The actual "success" of onboarding is a multi-step process (PR creation, merge).
+      Logger.log(`Feed onboarding process for '${config.name}' initiated with status: ${result.status}, ID: ${result.onboardingId}`);
+      return result;
+    } catch (error) {
+      Logger.error(`Failed to initiate feed onboarding for '${config.name}':`, error);
+      throw error; // Or return a specific error status object
+    }
+  }
 }
 
 // Export a singleton instance

package/src/utils/adoUtils.ts

@@ -0,0 +1,291 @@
+import { RequirementConfig, RegistryConfig } from '../core/types.js';
+import { SETTINGS_DIR } from '../core/constants.js';
+import { Logger } from './logger.js';
+import { exec, execSync } from 'child_process';
+import util from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import { isToolInstalled } from './osUtils.js'; // Assuming this can be adapted or a similar check is fine
+
+const execAsync = util.promisify(exec);
+
+export interface AdoArtifactResult {
+    type: 'npm' | 'pip';
+    package: string;
+    registryUrl: string;
+    folderPath?: string; // Only for npm
+    version: string;
+}
+
+/**
+ * Sets up the NPM credential provider.
+ * Installs @microsoft/artifacts-npm-credprovider if not already installed.
+ * @private
+ */
+async function _setupNpmCredentialProvider(): Promise<void> {
+    Logger.debug('Setting up NPM credential provider...');
+    const credProviderCommand = 'artifacts-npm-credprovider';
+
+    // Check if artifacts-npm-credprovider is installed by trying to get its version or a known command.
+    // A more robust check might involve checking a specific version or path.
+    let installed = false;
+    try {
+        // Attempt to get help output as a basic check for presence
+        const { stdout, stderr } = await execAsync(`${credProviderCommand} --help`);
+        Logger.debug(`${credProviderCommand} --help stdout: ${stdout}`);
+        if (stderr) Logger.debug(`${credProviderCommand} --help stderr: ${stderr}`);
+        installed = true;
+        Logger.debug(`${credProviderCommand} appears to be installed.`);
+    } catch (e) {
+        Logger.debug(`${credProviderCommand} not found or --help failed, attempting installation. Error: ${e}`);
+    }
+
+    if (!installed) {
+        Logger.log(`Installing @microsoft/artifacts-npm-credprovider...`);
+        try {
+            const installCommand = `npm install -g @microsoft/artifacts-npm-credprovider --registry https://pkgs.dev.azure.com/mseng/226da8e7-b1c0-4167-9678-53f461e07706/_packaging/AzureArtifacts/npm/registry/`;
+            const { stdout: installStdout, stderr: installStderr } = await execAsync(installCommand);
+            Logger.debug(`@microsoft/artifacts-npm-credprovider install stdout: ${installStdout}`);
+            if (installStderr) Logger.debug(`@microsoft/artifacts-npm-credprovider install stderr: ${installStderr}`);
+            Logger.log('@microsoft/artifacts-npm-credprovider installed successfully.');
+        } catch (error) {
+            Logger.error('Failed to install @microsoft/artifacts-npm-credprovider', error);
+            throw new Error(`Failed to install @microsoft/artifacts-npm-credprovider: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+
+/**
+ * Installs pip requirements: keyring and artifacts-keyring.
+ * @param pythonCommand The python command to use (e.g., 'python' or 'python3').
+ * @private
+ */
+async function _installPipRequirements(pythonCommand: string): Promise<void> {
+    Logger.debug(`Installing pip requirements: keyring, artifacts-keyring using ${pythonCommand}`);
+    try {
+        const command = `${pythonCommand} -m pip install keyring artifacts-keyring`;
+        const { stdout, stderr } = await execAsync(command);
+        Logger.debug(`pip install keyring artifacts-keyring stdout: ${stdout}`);
+        if (stderr) Logger.debug(`pip install keyring artifacts-keyring stderr: ${stderr}`);
+        Logger.log('Successfully installed keyring and artifacts-keyring.');
+    } catch (error) {
+        Logger.error('Failed to install pip requirements (keyring, artifacts-keyring)', error);
+        throw new Error(`Failed to install pip requirements: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * Configures NPM authentication for Azure DevOps Artifacts in a specified directory.
+ * This includes setting up the credential provider, creating an .npmrc file,
+ * and running the credential provider.
+ * @param execPromise The promise-based exec function.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param directoryPath The directory where .npmrc will be created and commands will be executed.
+ * @private
+ */
+async function _configureNpmAdoAuthInDirectory(
+    execPromise: (command: string, options?: { cwd?: string; env?: NodeJS.ProcessEnv }) => Promise<{ stdout: string; stderr: string }>,
+    registry: RegistryConfig['artifacts'],
+    directoryPath: string
+): Promise<void> {
+    if (!registry || !registry.registryUrl || !registry.registryName) {
+        throw new Error('Registry name and URL are required for NPM ADO auth configuration.');
+    }
+
+    await _setupNpmCredentialProvider();
+
+    const npmrcContent = `@${registry.registryName}:registry=${registry.registryUrl}\nalways-auth=true`;
+    const npmrcPath = path.join(directoryPath, '.npmrc');
+    await fs.writeFile(npmrcPath, npmrcContent.trim());
+    Logger.debug(`Created/Updated .npmrc file at: ${npmrcPath}`);
+
+    const env = { ...process.env, NUGET_CREDENTIALPROVIDER_VSTS_TOKENTYPE: 'SelfDescribing' };
+    Logger.debug(`Running artifacts-npm-credprovider in ${directoryPath}`);
+    const { stdout: credProviderStdout, stderr: credProviderStderr } = await execPromise('artifacts-npm-credprovider', { cwd: directoryPath, env });
+    Logger.debug(`artifacts-npm-credprovider stdout: ${credProviderStdout}`);
+    if (credProviderStderr) Logger.debug(`artifacts-npm-credprovider stderr: ${credProviderStderr}`);
+    Logger.log(`Successfully ran artifacts-npm-credprovider in ${directoryPath}`);
+}
+
+/**
+ * Handles fetching and setting up an Azure DevOps artifact.
+ * @param requirement The requirement configuration.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param pythonCommand Optional Python command (e.g., 'python', 'python3') for pip operations.
+ * @param targetDir Optional target directory for npm artifact setup. If not provided, a default will be used.
+ * @returns A promise that resolves with the artifact details.
+ */
+export async function handleArtifact(
+    requirement: RequirementConfig,
+    registry: RegistryConfig['artifacts'],
+    pythonCommand: string = 'python', // Default to 'python' if not provided
+    targetDir?: string // Optional target directory for npm
+): Promise<AdoArtifactResult> {
+    if (!registry) {
+        throw new Error('Azure DevOps artifacts registry configuration is required.');
+    }
+    if (!registry.registryName || !registry.registryUrl) {
+        throw new Error('Registry name and URL are required for Azure DevOps artifacts.');
+    }
+
+    Logger.debug(`Handling ADO artifact for requirement: ${requirement.name}, type: ${requirement.type}`);
+
+    if (requirement.type === 'npm') {
+        const requirementDir = targetDir || path.join(SETTINGS_DIR, 'requirements', requirement.name, requirement.version);
+        await fs.mkdir(requirementDir, { recursive: true });
+        Logger.debug(`Ensured directory for npm requirement: ${requirementDir}`);
+
+        try {
+            await _configureNpmAdoAuthInDirectory(execAsync, registry, requirementDir);
+            Logger.log(`Successfully configured ADO NPM auth for ${requirement.name} in ${requirementDir}`);
+
+            const version = requirement.version.includes('latest') ? 'latest' : requirement.version;
+            return {
+                folderPath: requirementDir,
+                type: 'npm',
+                package: `@${registry.registryName}/${requirement.name}`,
+                registryUrl: registry.registryUrl,
+                version: version
+            };
+        } catch (error) {
+            Logger.error(`Failed to configure ADO NPM auth for ${requirement.name} in ${requirementDir}`, error);
+            throw new Error(`ADO NPM auth configuration failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+
+    } else if (requirement.type === 'pip') {
+        await _installPipRequirements(pythonCommand);
+
+        const packageName = requirement.version.toLowerCase().includes('latest')
+            ? `${requirement.name} --upgrade`
+            : `${requirement.name}==${requirement.version}`;
+
+        Logger.log(`Pip requirement ${packageName} configured with registry ${registry.registryUrl}`);
+        return {
+            type: 'pip',
+            package: packageName,
+            registryUrl: registry.registryUrl,
+            version: requirement.version
+        };
+    } else {
+        throw new Error(`Unsupported requirement type for ADO artifact: ${requirement.type}`);
+    }
+}
+
+/**
+ * Get the latest version of an artifact from Azure DevOps.
+ * This is a simplified implementation and might require further enhancements for robust authentication and error handling.
+ * @param execPromise The promise-based exec function.
+ * @param requirement The requirement configuration.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param options Optional server install options (e.g., for pythonCommand).
+ * @returns The latest version string, or undefined if not found or an error occurs.
+ */
+export async function getArtifactLatestVersion(
+    requirement: RequirementConfig,
+    registry: RegistryConfig['artifacts'],
+    options?: import('../core/types.js').ServerInstallOptions, // Added import for ServerInstallOptions
+    targetDir?: string // Optional target directory for npm
+): Promise<string | undefined> {
+    if (!registry || !registry.registryUrl) {
+        Logger.error('ADO Artifact registry URL is missing for fetching latest version.');
+        return undefined;
+    }
+
+    Logger.debug(`Attempting to fetch latest version for ADO artifact: ${requirement.name} of type ${requirement.type}`);
+
+    if (requirement.type === 'npm') {
+        if (!registry.registryName) { // Ensure registryName is present
+            Logger.error('NPM ADO Artifact registry name is missing for fetching latest version.');
+            return undefined;
+        }
+
+        const requirementDir = targetDir || path.join(SETTINGS_DIR, 'requirements', requirement.name, requirement.version);
+
+        try {
+            await fs.mkdir(requirementDir, { recursive: true });
+            Logger.debug(`Ensured directory for NPM ADO version check: ${requirementDir}`);
+
+            // Configure auth within the requirementDir
+            await _configureNpmAdoAuthInDirectory(execAsync, registry, requirementDir);
+            Logger.log(`Successfully configured ADO NPM auth for version check of ${requirement.name} in ${requirementDir}`);
+
+            const fullPackageName = `@${registry.registryName}/${requirement.name}`;
+            const command = `npm view ${fullPackageName} version --registry ${registry.registryUrl}`;
+            Logger.debug(`Executing for NPM ADO latest version: ${command} in ${requirementDir}`);
+
+            const { stdout, stderr } = await execAsync(command, { cwd: requirementDir });
+
+            if (stderr && !stdout.trim()) {
+                Logger.error(`Error fetching NPM ADO version for ${fullPackageName} via npm view: ${stderr}`);
+                return undefined;
+            }
+
+            const version = stdout.trim();
+            if (version) {
+                Logger.debug(`Found latest NPM ADO version for ${fullPackageName}: ${version}`);
+                return version;
+            } else {
+                Logger.log(`Could not parse latest NPM version from ADO for ${fullPackageName} from output: '${stdout}'`);
+                return undefined;
+            }
+        } catch (error) {
+            Logger.error(`Exception fetching latest NPM version from ADO for ${requirement.name} in ${requirementDir}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    } else if (requirement.type === 'pip') {
+        try {
+            const pythonCmd = options?.settings?.pythonEnv as string || 'python';
+            const pipCmd = `${pythonCmd} -m pip`;
+
+            // Ensure keyring and artifacts-keyring are installed.
+            // This is usually handled by `handleArtifact` during install.
+            // For a standalone version check, we might need to ensure they exist.
+            // Consider calling _installPipRequirements(pythonCmd) if necessary, but it has side effects.
+            // For now, assume they are present if ADO pip artifacts are being used.
+
+            const command = `${pipCmd} index versions ${requirement.name} --extra-index-url ${registry.registryUrl}`;
+            Logger.debug(`Executing for Pip ADO latest version: ${command}`);
+            const { stdout, stderr } = await execAsync(command);
+
+            if (stderr && !stdout.trim()) { // If there's stderr and no significant stdout, it's likely an error
+                Logger.error(`Error fetching Pip ADO version for ${requirement.name}: ${stderr}`);
+                return undefined;
+            }
+
+            // Parse output like:
+            // mypackage (1.0.0)
+            // Available versions: 1.0.0, 0.9.0
+            // LATEST:          1.0.0
+            // Or:
+            // mypackage
+            // VERSIONS: 1.0.0, 0.9.0
+            // Latest: 1.0.0
+            const latestMatch = stdout.match(/(?:LATEST|Latest):\s*([^\s]+)/);
+            if (latestMatch && latestMatch[1]) {
+                Logger.debug(`Found latest Pip ADO version via LATEST line: ${latestMatch[1]}`);
+                return latestMatch[1];
+            }
+
+            // Fallback: try to parse 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()).filter(v => v);
+                if (versions.length > 0) {
+                    // This is a naive approach, assumes the first listed is relevant or latest.
+                    // Proper sorting (e.g. semver) would be better.
+                    Logger.debug(`Found Pip ADO versions: ${versions.join(', ')}. Taking the first one: ${versions[0]}`);
+                    return versions[0];
+                }
+            }
+
+            Logger.log(`Could not parse latest Pip version from ADO for ${requirement.name} from output: ${stdout}`); // Changed Logger.warn to Logger.log
+            return undefined;
+        } catch (error) {
+            Logger.error(`Exception fetching latest Pip version from ADO for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+
+    Logger.log(`getArtifactLatestVersion not implemented for type '${requirement.type}' or encountered an issue.`); // Changed Logger.warn to Logger.log
+    return undefined;
+}

package/src/utils/clientUtils.ts

@@ -1,9 +1,6 @@
 import fs from 'fs/promises';
-import * as fsSync from 'fs';
 import * as path from 'path';
-import { execSync } from 'child_process';
 import extractZipModule from 'extract-zip';
-import { Logger } from './logger.js';
 
 /**
  * Extract a zip file to a directory
@@ -37,47 +34,6 @@ export async function extractZipFile(zipPath: string, options: { dir: string }):
 }
 
 
-/**
- * Resolves the path to an NPM module, replacing template variables
- * First checks if the module path exists under NVM-controlled Node, then falls back to global npm
- * @param pathString The path string potentially containing template variables
- * @returns The resolved path
- */
-export function resolveNpmModulePath(pathString: string): string {
-    // If the path doesn't contain the ${NPMPATH} template, return it as is
-    if (!pathString.includes('${NPMPATH}')) {
-        return pathString;
-    }
-
-    // First try to get NVM-controlled npm path
-    const nvmHome = process.env.NVM_HOME;
-    if (nvmHome) {
-        try {
-            // Get current node version
-            const nodeVersion = execSync('node -v').toString().trim();
-
-            // Construct the path to npm in the NVM directory
-            const nvmNodePath = path.join(nvmHome, nodeVersion);
-            const resolvedPath = pathString.replace('${NPMPATH}', nvmNodePath);
-            // Check if this path exists
-            try {
-                fsSync.accessSync(resolvedPath);
-                return resolvedPath;
-            } catch (error) {
-                Logger.debug(`NVM controlled path doesn't exist: ${resolvedPath}, will try global npm`);
-                // Path doesn't exist, will fall back to global npm
-            }
-        } catch (error) {
-            Logger.debug(`Error determining Node version: ${error}, will use global npm`);
-            // Error getting node version, will fall back to global npm
-        }
-    }
-
-    // Fall back to global npm path
-    const globalNpmPath = execSync('npm root -g').toString().trim();
-    return pathString.replace('${NPMPATH}', globalNpmPath);
-}
-
 /**
  * Reads a JSON file and parses its content
  * @param filePath Path to the JSON file