imcp 0.0.19 → 0.1.2

package/src/services/InstallationService.ts

@@ -1,72 +1,78 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { exec } from 'child_process';
-import util from 'util';
 import {
   ServerInstallOptions,
-  ServerOperationResult,
-  FeedConfiguration,
-  RequirementConfig,
-  OperationStatus,
-  RequirementStatus,
-  McpConfig
+  ServerOperationResult
 } from '../core/metadatas/types.js';
-import { RequirementInstaller, InstallerFactory, createInstallerFactory } from '../core/installers/index.js';
-import { SUPPORTED_CLIENTS } from '../core/metadatas/constants.js';
 import { ClientInstaller } from '../core/installers/clients/ClientInstaller.js';
 import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js';
 import { Logger } from '../utils/logger.js';
-
-const execPromise = util.promisify(exec);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import { requirementService } from './RequirementService.js';
+import { InstallOperationManager } from '../core/loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../core/metadatas/recordingConstants.js';
 
 /**
  * Handles the actual installation process for an MCP server.
  */
 export class InstallationService {
-  private activeInstallations: Map<string, OperationStatus> = new Map();
-  private installerFactory: InstallerFactory;
 
   constructor() {
-    this.installerFactory = createInstallerFactory();
-  }
-
-  private generateOperationId(): string {
-    return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    // Constructor is now empty after removing installerFactory initialization
   }
 
   /**
-   * Installs a server based on the provided options and feed configuration.
+   * Installs a server based on the provided options.
+   * @param categoryName The category name of the server.
    * @param serverName The name of the server to install.
    * @param options The installation options.
    * @returns A result object indicating success or failure.
    */
   async install(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult> {
+    // Reset any previous operation status for this server before starting a new one.
+    const recoder = await InstallOperationManager.getInstance(categoryName, serverName).resetOperation();
     const configProvider = ConfigurationProvider.getInstance();
-    const clients = options.targetClients || Object.keys(SUPPORTED_CLIENTS);
+
+    const clients = options.targetClients || [];
 
     // Process updates for requirements if specified in options
-    // Fire off requirement updates in the background without awaiting completion
     if (options.requirements && options.requirements.length > 0) {
-      // Start the process but don't await it - it will run in the background
-      this.processRequirementUpdates(categoryName, serverName, options)
-        .catch(error => {
-          console.error(`Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`);
-        });
+      recoder.recordingAsync(
+        () => requirementService.processRequirementUpdates(categoryName, serverName, options),
+        {
+          stepName: RecordingConstants.STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE,
+          onError: (error) => {
+            const errorMsg = `Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(errorMsg);
+            return errorMsg;
+          },
+          onComplete: () => {
+            if (clients.length === 0) recoder.markOverallStatus('completed', 'Requirement updates completed.');
+          }
+        }
+      );
     }
 
-    // Check if server is already ready
-    const isReady = await configProvider.isServerReady(categoryName, serverName, clients);
+    if (!clients || clients.length === 0) {
+      const message = 'No clients specified for installation.';
+      return { success: true, message };
+    }
+
+    // Check if the server is already installed and ready
+    const readyMessage = 'Server and clients are already installed and ready';
+    const isReady = await recoder.recording(
+      () => configProvider.isServerReady(categoryName, serverName, clients),
+      {
+        stepName: RecordingConstants.STEP_CHECK_SERVER_READINESS,
+        inProgressMessage: 'Checking if server is already ready.',
+        endMessage: (ready: boolean) => ready ? 'Server and clients are already installed and ready' : 'Server is not ready. Proceeding with installation.',
+      }
+    )
     if (isReady) {
       return {
-        success: true,
-        message: 'Server and clients are already installed and ready',
+        success: true, message: readyMessage,
         status: [{
           status: 'completed',
           type: 'install',
           target: 'server',
-          message: 'Server and clients are already installed and ready'
+          message: readyMessage,
         }]
       };
     }
@@ -74,374 +80,23 @@ export class InstallationService {
     // Create new ClientInstaller instance for handling installation
     const clientInstaller = new ClientInstaller(categoryName, serverName, clients);
 
-    const requirementsResult = await this.checkAndInstallRequirements(categoryName, serverName, options);
-    if (requirementsResult) {
-      return requirementsResult;
-    }
-
-    // Process client installation regardless of requirements state
-    // Each client installer will check requirements before actual installation
-    return await clientInstaller.install(options);
-  }
-
-  /**
-   * Process requirement updates specified in serverInstallOptions
-   * All updates are processed in parallel for maximum efficiency
-   * @param categoryName The category name
-   * @param serverName The server name
-   * @param requirements The requirements to update
-   */
-  private async processRequirementUpdates(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<void> {
-    // Use UpdateCheckTracker to prevent concurrent updates
-    const updateCheckTracker = await import('../utils/UpdateCheckTracker.js').then(m => m.updateCheckTracker);
-    const operationKey = `requirement-updates-${categoryName}-${serverName}`;
-
-    // Check if there's already an update operation in progress for this server
-    const canProceed = await updateCheckTracker.startOperation(operationKey);
-    if (!canProceed) {
-      console.log(`Requirement updates for ${categoryName}/${serverName} already in progress, skipping`);
-      return;
-    }
-
-    try {
-      const configProvider = ConfigurationProvider.getInstance();
-      const feedConfig = await configProvider.getFeedConfiguration(categoryName);
-
-      if (!feedConfig) {
-        console.error(`Feed configuration not found for category: ${categoryName}`);
-        return;
-      }
-
-      // Import the RequirementService
-      const { requirementService } = await import('./RequirementService.js');
-
-      // Create an array of promises to update all requirements in parallel
-      const updatePromises = options.requirements?.map(async (reqToUpdate) => {
-        try {
-          // Find the full requirement config
-          const reqConfig = feedConfig.requirements?.find((r: RequirementConfig) => r.name === reqToUpdate.name);
-
-          if (!reqConfig) {
-            console.error(`Requirement configuration not found for: ${reqToUpdate.name}`);
-            return;
-          }
-
-          // Get current status
-          const currentStatus = await configProvider.getRequirementStatus(categoryName, reqToUpdate.name);
-
-          if (!currentStatus) {
-            console.error(`No current status found for requirement: ${reqToUpdate.name}`);
-            return;
-          }
-
-          // Update requirement status to indicate update in progress
-          await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-            ...currentStatus,
-            name: reqToUpdate.name,
-            type: currentStatus.type || 'unknown',
-            installed: currentStatus.installed || false,
-            inProgress: true,
-            operationStatus: {
-              status: 'in-progress',
-              type: 'update',
-              target: 'requirement',
-              message: `Updating ${reqToUpdate.name} from ${currentStatus.version || 'unknown'} to ${reqToUpdate.version}`
-            }
-          });
-
-
-          // For pip requirements, check if we have a stored pythonEnv
-          if (reqConfig.type === 'pip' && currentStatus.pythonEnv && !options?.settings?.pythonEnv) {
-            options = {
-              ...options,
-              settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
-            };
-          }
-
-          // Update the requirement with options for pip environment
-          const updatedStatus = await requirementService.updateRequirement(reqConfig, reqToUpdate.version, options);
-
-          // Update requirement status
-          await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-            ...updatedStatus,
-            name: reqToUpdate.name,
-            type: updatedStatus.type || currentStatus.type || 'unknown',
-            installed: updatedStatus.installed,
-            inProgress: false,
-            operationStatus: {
-              status: updatedStatus.installed ? 'completed' : 'failed',
-              type: 'update',
-              target: 'requirement',
-              message: updatedStatus.installed
-                ? `Successfully updated ${reqToUpdate.name} to version ${reqToUpdate.version}`
-                : `Failed to update ${reqToUpdate.name} to version ${reqToUpdate.version}`
-            },
-            availableUpdate: updatedStatus.installed ? undefined : currentStatus.availableUpdate
-          });
-
-          console.log(`Requirement ${reqToUpdate.name} updated to version ${reqToUpdate.version}`);
-        } catch (error) {
-          console.error(`Error updating requirement ${reqToUpdate.name}:`, error);
-
-          // Update status to indicate failure
-          await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-            name: reqToUpdate.name,
-            type: 'unknown',
-            installed: false,
-            inProgress: false,
-            error: error instanceof Error ? error.message : String(error),
-            operationStatus: {
-              status: 'failed',
-              type: 'update',
-              target: 'requirement',
-              message: `Error updating requirement: ${error instanceof Error ? error.message : String(error)}`
-            }
-          });
-        }
-      });
-
-      // Wait for all updates to complete in parallel if there are any
-      if (updatePromises) {
-        await Promise.all(updatePromises);
-      }
-    } finally {
-      // Always release the lock when done, even if there was an error
-      await updateCheckTracker.endOperation(operationKey);
-    }
-  }
-
-  /**
-   * Checks and installs requirements for a server if needed
-   * @param categoryName The category name
-   * @param serverName The server name
-   * @param options The installation options
-   * @returns A failure result if requirements check fails, null if requirements are satisfied
-   */
-  private async checkAndInstallRequirements(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult | null> {
-    const configProvider = ConfigurationProvider.getInstance();
-
-    // Get feed configuration to get requirements
-    const feedConfig = await configProvider.getFeedConfiguration(categoryName);
-    if (!feedConfig) {
-      return {
-        success: false,
-        message: 'Feed configuration not found',
-        status: [{
-          status: 'failed',
-          type: 'install',
-          target: 'server',
-          message: 'Feed configuration not found'
-        }]
-      };
-    }
-
-    // Find server config and verify requirements
-    const serverConfig = feedConfig.mcpServers.find((s: McpConfig) => s.name === serverName);
-    if (!serverConfig?.dependencies?.requirements) {
-      Logger.debug(`No requirements for ${serverName}`);
-      return null;
-    }
+    // Check and install requirements using RequirementService
+    const requirementsResult = await requirementService.checkAndInstallRequirements(categoryName, serverName, options);
 
-    // Check all requirements installation status
-    const requirementStatuses = await Promise.all(
-      serverConfig.dependencies.requirements.map(async (req) => {
-        const reqConfig = feedConfig.requirements?.find((r: RequirementConfig) => r.name === req.name) || {
-          name: req.name,
-          version: req.version,
-          type: 'npm'
-        };
-        return await this.installerFactory.checkInstallation(reqConfig, options);
+    // trigger a backend requirement check
+    await requirementService.checkServerRequirementForUpdateAsync(categoryName, serverName)
+      .then(() => {
+        Logger.info(`Requirement check for ${categoryName}:${serverName} completed successfully.`);
       })
-    );
-
-    // If all requirements are installed and ready, no need to proceed with installation
-    if (requirementStatuses.every(status => status.installed)) {
-      // Check if requirements are ready via ConfigurationProvider
-      const requirementsReady = await configProvider.isRequirementsReady(categoryName, serverName);
-
-      // Update requirement status if not ready
-      if (!requirementsReady) {
-        for (const status of requirementStatuses) {
-          await configProvider.updateRequirementStatus(categoryName, status.name, status);
-        }
-      }
-      return null;
-    }
-
-    // Sort requirements by order for installation
-    const sortedRequirements = [...serverConfig.dependencies.requirements].sort((a, b) => {
-      const orderA = a.order ?? Infinity;
-      const orderB = b.order ?? Infinity;
-      return orderA - orderB;
-    });
-
-    // Start requirements installation in background
-    this.installRequirementsInBackground(categoryName, sortedRequirements, options)
-      .catch(error => {
-        Logger.error(`Error in background requirement installations: ${error instanceof Error ? error.message : String(error)}`);
+      .catch((error) => {
+        Logger.error(`Requirement check for ${categoryName}:${serverName} failed: ${error instanceof Error ? error.message : String(error)}`);
       });
 
-    // Return immediately while installation continues in background
-    return null;
-  }
-
-  /**
-   * Installs requirements in background without blocking the main thread
-   * Requirements with the same order are installed in parallel
-   */
-  private async installRequirementsInBackground(
-    categoryName: string,
-    sortedRequirements: Array<{ name: string; version: string; order?: number }>,
-    options: ServerInstallOptions
-  ): Promise<void> {
-    const configProvider = ConfigurationProvider.getInstance();
-
-    // Group requirements by order
-    type RequirementType = { name: string; version: string; order?: number };
-    const requirementGroups = sortedRequirements.reduce<Record<number, RequirementType[]>>((groups, req) => {
-      const order = req.order ?? Infinity;
-      if (!groups[order]) {
-        groups[order] = [];
-      }
-      groups[order].push(req);
-      return groups;
-    }, {});
-
-    // Process each group in sequence, but requirements within group in parallel
-    const orderKeys = Object.keys(requirementGroups).map(Number).sort((a, b) => a - b);
-    for (const order of orderKeys) {
-      const group = requirementGroups[order];
-
-      await Promise.all(group.map(async requirement => {
-        try {
-          const feeds = await configProvider.getFeedConfiguration(categoryName);
-          const requirementConfig = feeds?.requirements?.find((r: RequirementConfig) => r.name === requirement.name) || {
-            name: requirement.name,
-            version: requirement.version,
-            type: 'npm'
-          };
-
-          // For pip requirements, check if we need to use stored pythonEnv
-          const currentStatus = await configProvider.getRequirementStatus(categoryName, requirement.name);
-          if (requirementConfig.type === 'pip' && currentStatus?.pythonEnv && !options?.settings?.pythonEnv) {
-            options = {
-              ...options,
-              settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
-            };
-          }
-
-          const installer = this.installerFactory.getInstaller(requirementConfig);
-          if (!installer) {
-            await this.updateRequirementFailureStatus(
-              categoryName,
-              requirement.name,
-              requirementConfig.type,
-              `No installer found for requirement type: ${requirementConfig.type}`
-            );
-            return;
-          }
-
-          const operationId = this.generateOperationId();
-          await this.updateRequirementProgressStatus(
-            categoryName,
-            requirement.name,
-            requirementConfig.type,
-            operationId
-          );
-
-          const installStatus = await installer.install(requirementConfig, options);
-          await this.updateRequirementCompletionStatus(
-            categoryName,
-            requirement.name,
-            installStatus,
-            operationId
-          );
-        } catch (error) {
-          await this.updateRequirementFailureStatus(
-            categoryName,
-            requirement.name,
-            'unknown',
-            error instanceof Error ? error.message : String(error)
-          );
-        }
-      }));
+    if (requirementsResult && !requirementsResult.success) {
+      await recoder.recordStep('RequirementInstallationCheck', 'failed', requirementsResult.error?.message || requirementsResult.message || 'Requirement installation failed.');
+      return requirementsResult;
     }
-  }
-
-  /**
-   * Helper to update requirement status for failure case
-   */
-  private async updateRequirementFailureStatus(
-    categoryName: string,
-    requirementName: string,
-    requirementType: string,
-    errorMessage: string
-  ): Promise<void> {
-    const configProvider = ConfigurationProvider.getInstance();
-    await configProvider.updateRequirementStatus(categoryName, requirementName, {
-      name: requirementName,
-      type: requirementType,
-      installed: false,
-      error: errorMessage,
-      operationStatus: {
-        status: 'failed',
-        type: 'install',
-        target: 'requirement',
-        message: `Error installing requirement: ${errorMessage}`,
-        operationId: this.generateOperationId()
-      }
-    });
-  }
 
-  /**
-   * Helper to update requirement status for in-progress case
-   */
-  private async updateRequirementProgressStatus(
-    categoryName: string,
-    requirementName: string,
-    requirementType: string,
-    operationId: string
-  ): Promise<void> {
-    const configProvider = ConfigurationProvider.getInstance();
-    await configProvider.updateRequirementStatus(categoryName, requirementName, {
-      name: requirementName,
-      type: requirementType,
-      installed: false,
-      inProgress: true,
-      operationStatus: {
-        status: 'in-progress',
-        type: 'install',
-        target: 'requirement',
-        message: `Installing requirement: ${requirementName}`,
-        operationId
-      }
-    });
-  }
-
-  /**
-   * Helper to update requirement status for completion case
-   */
-  private async updateRequirementCompletionStatus(
-    categoryName: string,
-    requirementName: string,
-    installStatus: RequirementStatus,
-    operationId: string
-  ): Promise<void> {
-    const configProvider = ConfigurationProvider.getInstance();
-    await configProvider.updateRequirementStatus(categoryName, requirementName, {
-      ...installStatus,
-      operationStatus: {
-        status: installStatus.installed ? 'completed' : 'failed',
-        type: 'install',
-        target: 'requirement',
-        message: installStatus.installed
-          ? `Requirement ${requirementName} installed successfully`
-          : `Failed to install ${requirementName}`,
-        operationId
-      }
-    });
+    return await clientInstaller.install(options);
   }
 }
-
-// Export a singleton instance (optional)
-// export const installationService = new InstallationService();