imcp 0.1.4 → 0.1.5

package/src/core/installers/requirements/PipInstaller.ts

@@ -1,207 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
-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 { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
-import * as RecordingConstants from '../../metadatas/recordingConstants.js';
-/**
- * Installer implementation for Python packages using pip
- */
-export class PipInstaller extends BaseInstaller {
-    private getPythonCommand(options?: ServerInstallOptions): string {
-        return options?.settings?.pythonEnv as string || 'python';
-    }
-
-    private getPipCommand(options?: ServerInstallOptions): string {
-        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: RequirementConfig): boolean {
-        return requirement.type === 'pip';
-    }
-
-    supportCheckUpdates(): boolean {
-        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: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined> {
-        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: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
-        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: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
-
-        return await recorder.recording(
-            async (): Promise<RequirementStatus> => {
-                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: string
-
-                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: string;
-                    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),
-                    };
-                },
-            });
-    }
-}

package/src/core/loaders/InstallOperationManager.ts

@@ -1,367 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { SETTINGS_DIR } from '../metadatas/constants.js';
-import { InstallOperationDetails, InstallOperationStep } from '../metadatas/types.js';
-import { Logger } from '../../utils/logger.js';
-
-const INSTALL_STATUS_DIR = path.join(SETTINGS_DIR, 'InstallOperationStatus');
-
-export class InstallOperationManager {
-  private installOperationStatus: Record<string, InstallOperationDetails> = {};
-  private statusLock: Promise<void> = Promise.resolve();
-  private readonly categoryName: string;
-  private readonly serverName: string;
-  private readonly statusFilePath: string;
-
-  /**
-   * Creates an InstallOperationManager instance for a specific category and server.
-   * @param categoryName The name of the category.
-   * @param serverName The name of the server.
-   */
-  constructor(categoryName: string, serverName: string) {
-    this.categoryName = categoryName;
-    this.serverName = serverName;
-    this.statusFilePath = path.join(
-      INSTALL_STATUS_DIR,
-      this.categoryName,
-      `${this.serverName}.json`
-    );
-    this.loadStatuses().catch(error => Logger.error('Failed to initialize InstallOperationManager:', error));
-  }
-
-  /**
-   * Returns an InstallOperationManager instance for the given category and server.
-   * @param categoryName The name of the category.
-   * @param serverName The name of the server.
-   */
-  private static instanceMap: Map<string, InstallOperationManager> = new Map();
-
-  /**
-   * Returns a cached InstallOperationManager instance for the given category and server.
-   * If an instance does not exist, it will be created and cached.
-   * @param categoryName The name of the category.
-   * @param serverName The name of the server.
-   */
-  public static getInstance(categoryName: string, serverName: string): InstallOperationManager {
-    const key = `${categoryName}::${serverName}`;
-    if (!this.instanceMap.has(key)) {
-      this.instanceMap.set(key, new InstallOperationManager(categoryName, serverName));
-    }
-    return this.instanceMap.get(key)!;
-  }
-
-  private async withLock<T>(operation: () => Promise<T>): Promise<T> {
-    const current = this.statusLock;
-    let resolve: () => void;
-    this.statusLock = new Promise<void>(r => resolve = r);
-    try {
-      await current;
-      return await operation();
-    } finally {
-      resolve!();
-    }
-  }
-
-  private async loadStatuses(): Promise<void> {
-    await this.withLock(async () => {
-      try {
-        await fs.mkdir(path.dirname(this.statusFilePath), { recursive: true });
-        const data = await fs.readFile(this.statusFilePath, 'utf-8');
-        this.installOperationStatus = JSON.parse(data);
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-          this.installOperationStatus = {};
-          await this.saveStatuses(); // Create the file if it doesn't exist
-        } else {
-          Logger.error('Failed to load install operation statuses:', error);
-          this.installOperationStatus = {}; // Initialize with empty statuses in case of other errors
-        }
-      }
-    });
-  }
-
-  private async saveStatuses(): Promise<void> {
-    await fs.mkdir(path.dirname(this.statusFilePath), { recursive: true });
-    await fs.writeFile(this.statusFilePath, JSON.stringify(this.installOperationStatus, null, 2));
-  }
-
-  private get operationKey(): string {
-    return `${this.categoryName}-${this.serverName}`;
-  }
-
-  /**
-   * Record a step for this category/server instance.
-   */
-  public async recordStep(
-    stepName: string,
-    status: 'pending' | 'in-progress' | 'completed' | 'failed',
-    message?: string
-  ): Promise<InstallOperationDetails> {
-    return await this.withLock(async () => {
-      let operationDetails = this.installOperationStatus[this.operationKey];
-
-      const newStep: InstallOperationStep = {
-        name: stepName,
-        status,
-        message,
-        timestamp: new Date().toISOString(),
-      };
-
-      if (!operationDetails) {
-        operationDetails = {
-          currentStep: stepName,
-          steps: [newStep],
-          lastUpdated: new Date().toISOString(),
-          error: status === 'failed' ? message : undefined,
-          overallStatus: status === 'failed' ? 'failed' : 'in-progress',
-        };
-      } else {
-        // Check for an existing unfinished step with the same name
-        const existingStepIndex = operationDetails.steps.findIndex(
-          s => s.name === stepName && s.status !== 'completed' && s.status !== 'failed'
-        );
-        if (existingStepIndex !== -1) {
-          // Update the existing unfinished step
-          operationDetails.steps[existingStepIndex] = newStep;
-        } else {
-          operationDetails.steps.push(newStep);
-        }
-        operationDetails.currentStep = stepName;
-        operationDetails.lastUpdated = new Date().toISOString();
-
-        if (status === 'failed') {
-          operationDetails.overallStatus = 'failed';
-          if (!operationDetails.error) { // Store the first error
-            operationDetails.error = message;
-          }
-          // Mark all in-progress steps as cancelled
-          operationDetails.steps = operationDetails.steps.map(s =>
-            s.status === 'in-progress'
-              ? {
-                ...s,
-                status: 'canceled',
-                message: (s.message ? s.message + ' ' : '') + '[Canceled due to failure]',
-                timestamp: new Date().toISOString(),
-              }
-              : s
-          );
-        } else if (status === 'completed' && stepName.toLowerCase().includes('completed')) {
-          // Check if all steps are completed or if there are any failures
-          const allStepsCompleted = operationDetails.steps.every(s =>
-            s.status === 'completed' || (s.name === stepName && status === 'completed')
-          );
-          operationDetails.overallStatus = allStepsCompleted ? 'completed' : 'in-progress';
-          if (allStepsCompleted) {
-            operationDetails.error = undefined; // Clear error on completion
-          }
-        } else {
-          if (operationDetails.overallStatus !== 'failed') {
-            operationDetails.overallStatus = 'in-progress';
-          }
-        }
-      }
-
-      // Special handling for the "InstallCompleted" step or similar final step names
-      if (stepName === 'InstallCompleted') {
-        operationDetails.overallStatus = status === 'completed' ? 'completed' : 'failed';
-        if (status === 'completed') operationDetails.error = undefined;
-      }
-
-      this.installOperationStatus[this.operationKey] = operationDetails;
-      await this.saveStatuses();
-      return operationDetails;
-    });
-  }
-
-  /**
-   * Resets (deletes) the operation status for this category/server.
-   * This is useful to call before starting a new installation attempt.
-   */
-  public async resetOperation(): Promise<InstallOperationManager> {
-    await this.withLock(async () => {
-      if (this.installOperationStatus[this.operationKey]) {
-        delete this.installOperationStatus[this.operationKey];
-        Logger.info(`Reset installation operation status for ${this.operationKey}`);
-        await this.saveStatuses();
-      }
-    });
-    return this;
-  }
-
-  /**
-   * Gets the details for this category/server.
-   */
-  public async getDetails(): Promise<InstallOperationDetails | undefined> {
-    await this.loadStatuses(); // Ensure latest statuses are loaded
-    return this.installOperationStatus[this.operationKey];
-  }
-
-  /**
-   * Gets all operation details in this file (for this category/server).
-   */
-  public async getAllDetails(): Promise<Record<string, InstallOperationDetails>> {
-    await this.loadStatuses();
-    return this.installOperationStatus;
-  }
-
-  /**
-   * Explicitly mark the overall status of an operation as 'completed' or 'failed'.
-   * This can be used to force the final state regardless of step details.
-   * @param status 'completed' or 'failed'
-   * @param error Optional error message if failed
-   */
-  public async markOverallStatus(status: 'completed' | 'failed', error?: string): Promise<InstallOperationDetails | undefined> {
-    return await this.withLock(async () => {
-      const operationDetails = this.installOperationStatus[this.operationKey];
-      if (!operationDetails) return undefined;
-      operationDetails.overallStatus = status;
-      operationDetails.lastUpdated = new Date().toISOString();
-      if (status === 'failed') {
-        if (error) {
-          operationDetails.error = error;
-        }
-        // Mark all in-progress steps as cancelled
-        operationDetails.steps = operationDetails.steps.map(s =>
-          s.status === 'in-progress'
-            ? {
-              ...s,
-              status: 'canceled',
-              message: (s.message ? s.message + ' ' : '') + '[Canceled due to failure]',
-              timestamp: new Date().toISOString(),
-            }
-            : s
-        );
-      }
-      if (status === 'completed') {
-        operationDetails.error = undefined;
-      }
-      await this.saveStatuses();
-      return operationDetails;
-    });
-  }
-
-  /**
-   * Executes a function and records its step status as 'in-progress', 'completed', or 'failed'.
-   *
-   * Useful for wrapping tasks with consistent status tracking and flexible error handling.
-   *
-   * @template T The return type of the function being executed.
-   *
-   * @param fn The function to execute. Can be synchronous or asynchronous.
-   * @param options Optional configuration:
-   *  - stepName: Custom name for the step. Defaults to the function name or 'unnamedStep'.
-   *  - inProgressMessage: Optional message to log when the step starts.
-   *  - endMessage: Optional static string or function to generate a final message from the result or error.
-   *  - onResult: A function `(result: T) => boolean` that determines whether the step was successful. Defaults to always `true`.
-   *  - onError: Optional function `(error) => { result: T; message: string } | never` that handles an error and may return a fallback result and message, or throw.
-   *
-   * @returns A promise that resolves with the result of the function if successful, or rethrows on failure.
-   *
-   * @throws The original error or any error thrown from `onError`.
-   */
-  public async recording<T>(
-    fn: () => T | Promise<T>,
-    options?: {
-      stepName?: string;
-      inProgressMessage?: string;
-      endMessage?: string | ((data: T) => string | undefined);
-      onResult?: (result: T) => boolean;
-      onError?: (error: unknown) => { result: T; message: string } | Promise<{ result: T; message: string }> | never;
-    }
-  ): Promise<T> {
-    const { stepName, inProgressMessage = 'Step in progress', endMessage, onResult = () => true, onError } = options || {};
-
-    const resolvedStepName = stepName ?? (fn.name || 'unnamedStep');
-    const getEndMessage = (data: T, fallback: string) =>
-      typeof endMessage === 'function' ? endMessage(data) || 'Step completed' : endMessage ?? fallback;
-
-    await this.recordStep(resolvedStepName, 'in-progress', inProgressMessage);
-
-    try {
-      const result = await Promise.resolve(fn());
-      const isSuccess = onResult(result);
-      await this.recordStep(resolvedStepName, isSuccess ? 'completed' : 'failed', getEndMessage(result, isSuccess ? 'Step completed successfully' : 'Step failed'));
-      return result;
-    } catch (err) {
-      if (!onError) {
-        await this.recordStep(resolvedStepName, 'failed', (err as Error)?.message || String(err));
-        throw err;
-      }
-
-      try {
-        const { result, message } = await onError(err);
-        await this.recordStep(resolvedStepName, 'failed', message);
-        return result;
-      } catch (onErrorThrown) {
-        await this.recordStep(resolvedStepName, 'failed', (onErrorThrown as Error)?.message || String(onErrorThrown));
-        throw onErrorThrown;
-      }
-    }
-  }
-
-
-  /**
- * Executes an asynchronous "fire-and-forget" task and records its step status as 'in-progress', 'completed', or 'failed'.
- *
- * Unlike `recording`, this does not await the result — it runs the task in the background.
- * Useful for side-effecting operations like updates or notifications where progress should be logged but not block flow.
- *
- * @template T The resolved type of the asynchronous task.
- *
- * @param fn The async function to execute.
- * @param options Optional configuration:
- *  - stepName: Custom name for the step. Defaults to the function name or 'unnamedStep'.
- *  - inProgressMessage: Message to log when the step starts.
- *  - endMessage: Static string or function to generate the final message from result or error.
- *  - onResult: A boolean or function `(result: T) => boolean` to determine if the step is successful.
- *  - onError: A function `(error) => string` or `Promise<string>` to handle errors and return a message.
- *             If it throws, the error is rethrown and logged.
- *  - onComplete: Optional callback to run after completion, regardless of success or failure.
- *
- * @returns void
- */
-  public recordingAsync<T>(fn: () => Promise<T>, options?: {
-    stepName?: string;
-    inProgressMessage?: string;
-    endMessage?: string | ((result: T) => string);
-    onResult?: (result: T) => boolean;
-    onError?: (error: unknown) => string | Promise<string> | never;
-    onComplete?: () => void;
-  }
-  ): void {
-    const {
-      stepName,
-      inProgressMessage = 'Step in progress',
-      endMessage,
-      onResult = () => true,
-      onError,
-      onComplete,
-    } = options || {};
-
-    const resolvedStepName = stepName ?? (fn.name || 'unnamedStep');
-    const getMessage = (data: T, fallback: string) => typeof endMessage === 'function' ? endMessage(data) : endMessage ?? fallback;
-
-    this.recordStep(resolvedStepName, 'in-progress', inProgressMessage).then(() => {
-      fn()
-        .then(result => {
-          const isSuccess = onResult(result);
-          const message = getMessage(result, isSuccess ? 'Step completed successfully' : 'Step failed');
-          this.recordStep(resolvedStepName, isSuccess ? 'completed' : 'failed', message).then(onComplete).catch();
-        })
-        .catch(async (err) => {
-          if (onError) {
-            try {
-              const errorMessage = await onError(err);
-              await this.recordStep(resolvedStepName, 'failed', errorMessage);
-            } catch (onErrorThrown) {
-              await this.recordStep(resolvedStepName, 'failed', (onErrorThrown as Error)?.message || String(onErrorThrown));
-              throw onErrorThrown;
-            }
-          } else {
-            const fallback = getMessage(err, (err as Error)?.message || String(err));
-            await this.recordStep(resolvedStepName, 'failed', fallback);
-          }
-        });
-    });
-  }
-}