imcp 0.1.1 → 0.1.3

package/src/core/metadatas/recordingConstants.ts

@@ -0,0 +1,62 @@
+/**
+ * Step name constants for InstallOperationManager and step recording.
+ *
+ * This file defines all static step names and documents dynamic step name patterns
+ * used throughout the installation and onboarding process.
+ *
+ * Dynamic step names are documented as template string patterns.
+ */
+
+/** Step for processing all requirement updates in a batch operation. */
+export const STEP_PROCESS_REQUIREMENT_UPDATES = 'Processing all requirement updates';
+
+/** Step for checking the status of a specific requirement. */
+export const STEP_CHECKING_REQUIREMENT_STATUS = 'Checking the status of requirement';
+
+/** Step for installing requirements in the background process. */
+export const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = 'Installing requirements in the background';
+
+/** Step for checking and installing all requirements as needed. */
+export const STEP_CHECK_AND_INSTALL_REQUIREMENTS = 'Checking and installing all requirements';
+
+/** Step for running the install logic in the CommandInstaller. */
+export const STEP_COMMAND_INSTALLER_INSTALL = 'Running install in CommandInstaller';
+
+/** Step for running the install logic in the GeneralInstaller. */
+export const STEP_GENERAL_INSTALLER_INSTALL = 'Running install in GeneralInstaller';
+
+/** Step for executing the actual installation command (npm, pip, etc.). */
+export const STEP_INSTALLATION_COMMAND_EXECUTION = 'Executing installation command for requirement';
+
+/** Step for running the install logic in the PipInstaller. */
+export const STEP_PIP_INSTALLER_INSTALL = 'Running install in PipInstaller';
+
+/** Step for processing requirement updates in the RequirementService. */
+export const STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE = 'Processing requirement updates in RequirementService';
+
+/** Step for checking if the server is ready after installation. */
+export const STEP_CHECK_SERVER_READINESS = 'Checking server readiness after installation';
+
+/** Step for running the install logic in the NpmInstaller. */
+export const STEP_NPM_INSTALLER_INSTALL = 'Running install in NpmInstaller';
+
+/** Prefix for steps that update a specific requirement. */
+export const STEP_INSTALL_REQUIREMENT_PREFIX = 'Updating requirement:';
+
+/** Prefix for steps that execute an installation command for a requirement. */
+export const STEP_INSTALL_COMMAND_PREFIX = 'Executing installation command for:';
+
+/** Step for checking and installing the VS Code extension for the client. */
+export const STEP_CHECK_VSCODE_AND_INSTALL_EXTENSION = 'Checking and installing VS Code extension for client';
+
+/** Step for setting up the installation configuration (env, args, etc.). */
+export const STEP_SETUP_INSTALLATION_CONFIG = 'Setting up installation configuration';
+
+/** Step for updating VS Code settings for the client/server. */
+export const STEP_UPDATE_VSCODE_SETTINGS = 'Updating VS Code settings for client/server';
+
+/** Step for the overall installation process of a client or server. */
+export const STEP_INSTALLATION = 'Running overall installation process';
+
+/** Step for marking the initiation of an onboarding or installation process. */
+export const STEP_INITIATED = 'Initiating onboarding or installation process';

package/src/core/metadatas/types.ts

@@ -176,4 +176,27 @@ export interface MCPEventData {
   [MCPEvent.SERVER_STARTED]: { server: MCPServerCategory };
   [MCPEvent.SERVER_STOPPED]: { serverName: string };
   [MCPEvent.CONFIG_CHANGED]: { configuration: MCPConfiguration };
+}
+
+export interface InstallOperationStep {
+  name: string;
+  status: 'pending' | 'in-progress' | 'completed' | 'failed' | 'canceled';
+  message?: string;
+  isCritical?: boolean;
+  timestamp: string;
+}
+
+export interface InstallOperationDetails {
+  currentStep: string;
+  steps: InstallOperationStep[];
+  lastUpdated: string;
+  error?: string;
+  overallStatus: 'pending' | 'in-progress' | 'completed' | 'failed';
+}
+export interface SystemSettings {
+  pythonEnvs?: Record<string, string>;
+  nodePath?: string;
+  browserPath?: string;
+  systemEnvironments?: Record<string, string>;
+  userConfigurations?: Record<string, string>;
 }

package/src/core/onboard/OnboardStatusManager.ts

@@ -5,6 +5,7 @@ import { FeedConfiguration, McpConfig } from '../metadatas/types.js';
 import { OnboardStatus, OnboardingProcessStatus, OperationType } from './OnboardStatus.js';
 import { Logger } from '../../utils/logger.js';
 
+import * as RecordingConstants from '../metadatas/recordingConstants.js';
 const ONBOARD_STATUS_DIR = path.join(SETTINGS_DIR, 'onboard');
 const CATEGORY_OPERATIONS_STATUS_FILE = path.join(ONBOARD_STATUS_DIR, 'OnboardStatus.json');
 const FEED_CONFIG_DIR = path.join(ONBOARD_STATUS_DIR, 'feed_configs'); // Staging for feed configs during operation
@@ -306,7 +307,7 @@ export class OnboardStatusManager {
       feedName: categoryName,
       serverName,
       status: OnboardingProcessStatus.PENDING,
-      steps: [{ stepName: 'Initiated', timestamp: new Date().toISOString() }],
+      steps: [{ stepName: RecordingConstants.STEP_INITIATED, timestamp: new Date().toISOString() }],
       lastUpdated: new Date().toISOString(),
       operationType,
       errorMessage: undefined,

package/src/core/validators/StdioServerValidator.ts

@@ -8,6 +8,7 @@ import { MACRO_EXPRESSIONS, resolveNpmModulePath } from "../../utils/macroExpres
 import { getSystemPythonPackageDirectory } from "../../utils/osUtils.js";
 import { SETTINGS_DIR } from "../metadatas/constants.js";
 import path from "path";
+import { InstallOperationManager } from "../loaders/InstallOperationManager.js";
 
 const execPromise = util.promisify(exec);
 
@@ -57,7 +58,7 @@ export class StdioServerValidator implements IServerValidator {
    * @param requirement The requirement config to validate and install
    * @returns true if requirement is successfully installed/validated
    */
-  private async validateRequirement(requirement: RequirementConfig): Promise<boolean> {
+  private async validateRequirement(requirement: RequirementConfig, recorder: InstallOperationManager): Promise<boolean> {
     try {
       Logger.debug(`Validating/installing requirement: ${requirement.name}`);
       const installer = this.installerFactory.getInstaller(requirement);
@@ -69,7 +70,7 @@ export class StdioServerValidator implements IServerValidator {
       }
 
       const targetDir = this._getRequirementFolderPath(requirement);
-      const status = await installer.install(requirement, { settings: { folderName: targetDir } });
+      const status = await installer.install(requirement, recorder, { settings: { folderName: targetDir } });
       if (!status.installed) {
         const msg = `Failed to install requirement ${requirement.name}: ${status.error || 'Unknown error'}`;
         Logger.error(msg);
@@ -288,7 +289,7 @@ export class StdioServerValidator implements IServerValidator {
             type: 'npm' // Default to npm if not specified
           };
 
-          const isValid = await this.validateRequirement(reqConfig);
+          const isValid = await this.validateRequirement(reqConfig, InstallOperationManager.getInstance(config.name, server.name));
           if (!isValid) {
             throw new Error(`Dependency validation failed for: ${req.name}`);
           }

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();