imcp 0.0.19 → 0.1.2

package/memory-bank/progress.md

@@ -0,0 +1,35 @@
+# Progress Log
+
+- [YYYY-MM-DD HH:MM:SS] - Initializing Memory Bank.
+
+- [2025-05-16 09:22:36] - Completed: Made "IMCP Server Manager" title clickable in `src/web/public/index.html`.
+- [2025-05-16 13:28:10] - Completed: Refactored requirement management from `InstallationService` to `RequirementService`. Fixed `reqConfig` scoping and type fallbacks in `RequirementService.processRequirementUpdates`.
+
+[2025-05-16 16:07:34] - Completed: Redesign installation operation status and polling mechanism.
+  - Added `InstallOperationDetails` type to `src/core/metadatas/types.ts`.
+  - Created `InstallOperationManager` in `src/core/loaders/InstallOperationManager.ts`.
+  - Added API endpoint for installation status in `src/web/server.ts`.
+  - Integrated `recordStep` in `InstallationService`, `RequirementService`, and `BaseClientInstaller`.
+
+[2025-05-16 16:50:21] - Enhanced installation status:
+  - Added `overallStatus` to `InstallOperationDetails` in `src/core/metadatas/types.ts`.
+  - Updated `InstallOperationManager` in `src/core/loaders/InstallOperationManager.ts` to manage `overallStatus`.
+  - Modified frontend polling in `src/web/public/js/modal/installation.js` to use the new API `/api/categories/:categoryName/servers/:serverName/installation/status` and display detailed steps.
+
+[2025-05-17 00:26:16] - Began refactoring InstallOperationManager to be instance-based per category/server, with new file structure for status. Memory bank updated to reflect architectural and pattern changes.
+
+[2025-05-17 15:02:44] - Completed: Refactored `RequirementService.ts` to use instance-based `InstallOperationManager` and its `recording`/`recordingAsync` methods. This involved updating `processRequirementUpdates`, `checkAndInstallRequirements`, and `installRequirementsInBackground`.
+
+[2025-05-18 11:33:23] - Completed: Standardized step recording names by creating `src/core/metadatas/recordingConstants.ts`. This centralizes static step names and documents dynamic patterns for installation/onboarding operations.
+
+[2025-05-18 13:21:30] - Completed: Implemented main modal refresh logic to replace page reload.
+  - `loadingModal.js`: Dispatches `refreshMainModalContent` event on close.
+  - `installation.js`: Stores `categoryName` and `serverName` in `localStorage`.
+  - `modal.js`: Listens for event, retrieves context from `localStorage`, and calls `showInstallModal` with both `categoryName` and `serverName`.
+  - This resolves "Server configuration not found" errors and improves UX.
+[2025-05-17 15:26:15] - Refactored all requirement installer classes and factory to support InstallOperationManager step recording. All install methods now accept a recorder and log critical steps.
+
+[2025-05-19 00:14:13] - Completed: Updated settings page (`src/web/public/settings.html` and `src/web/public/js/settings.js`):
+  - Removed "NPM Global Package Path" display.
+  - Added prompt with a question icon for User Configurations, displayed on the same line as the section title.
+  - Implemented secret input type for keys containing "key" in User Configurations, with an eye icon button *inside* the value input field to toggle visibility (maintaining original input box sizes).

package/memory-bank/systemPatterns.md

@@ -0,0 +1,10 @@
+# System Patterns
+
+- [YYYY-MM-DD HH:MM:SS] - Initializing Memory Bank.
+
+[2025-05-18 13:21:30] - Implemented an event-driven modal refresh pattern for the installation UI.
+  - Pattern: Instead of page reloads, the loading modal (`loadingModal.js`) dispatches a custom DOM event (`refreshMainModalContent`) upon closing.
+  - Context Persistence: The initiating action (e.g., in `installation.js`) stores necessary context (like `lastSelectedCategory` and `lastSelectedServerName`) in `localStorage`.
+  - Event Handling: The main modal controller (`modal.js`) listens for this event, retrieves context from `localStorage`, and re-initializes/refreshes its content (`showInstallModal`) with the persisted context.
+  - Benefit: This decouples the loading modal from the main modal, allows for non-disruptive UI updates, and maintains user context effectively.
+[2025-05-17 00:26:06] - Changed InstallOperationManager from singleton/static to instance-based, with per-category/server file storage pattern: Settings_Dir/InstallOperationStatus/CategoryName/ServerName.json. This introduces a more granular, object-oriented persistence and management pattern for install operation status.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imcp",
-  "version": "0.0.19",
+  "version": "0.1.2",
   "description": "Node.js SDK for Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,6 +25,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "applicationinsights": "^2.9.3",
     "axios": "^1.6.2",
     "commander": "^11.1.0",
     "express": "^4.18.2",

package/src/cli/index.ts

@@ -8,19 +8,9 @@ import { createUninstallCommand } from './commands/uninstall.js';
 import { createPullCommand } from './commands/pull.js';
 import { mcpManager } from '../services/MCPManager.js';
 import { Logger } from '../utils/logger.js';
-import axios from 'axios';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import fs from 'fs';
-import { compareVersions } from '../utils/versionUtils.js';
+import { checkForUpdates } from '../utils/versionUtils.js';
 
 // Custom error interface for Commander.js errors
-// ANSI color codes
-const COLORS = {
-  reset: '\x1b[0m',
-  yellow: '\x1b[33m'
-};
-
 interface CommanderError extends Error {
   code?: string;
 }
@@ -81,43 +71,6 @@ process.on('unhandledRejection', (error: unknown) => {
   process.exit(1);
 });
 
-/**
- * Check if there's a newer version of the package available
- */
-
-async function checkForUpdates(): Promise<void> {
-  try {
-    // Get the current package version
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const packagePath = path.resolve(__dirname, '../../package.json');
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-    const currentVersion = packageJson.name && packageJson.version ? packageJson.version : '0.0.0';
-    const packageName = packageJson.name || 'imcp';
-
-    try {
-      // Get the latest version from npm registry (only for published packages)
-      const npmResponse = await axios.get(`https://registry.npmjs.org/${packageName}`);
-
-      if (npmResponse.data && npmResponse.data['dist-tags'] && npmResponse.data['dist-tags'].latest) {
-        const latestVersion = npmResponse.data['dist-tags'].latest;
-
-        // Compare versions properly to ensure we're only notifying for newer versions
-        if (latestVersion && compareVersions(latestVersion, currentVersion) > 0) {
-          console.log(`${COLORS.yellow}Update available for ${packageName}: ${currentVersion} → ${latestVersion}${COLORS.reset}`);
-          console.log(`${COLORS.yellow}Run \`npm install -g ${packageName}@latest\` to update${COLORS.reset}`);
-        }
-      }
-    } catch (npmError) {
-      // Log the npm error
-      Logger.debug(`Failed to check npm registry: ${npmError instanceof Error ? npmError.message : String(npmError)}`);
-    }
-  } catch (error) {
-    // Silently fail - don't interrupt the command if update check fails
-    Logger.debug(`Failed to check for updates: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
 // Start the CLI
 main().catch((error: unknown) => {
   if (error instanceof Error) {

package/src/core/installers/clients/BaseClientInstaller.ts

@@ -1,7 +1,7 @@
 import { Logger } from '../../../utils/logger.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { isCommandAvailable } from '../../../utils/osUtils.js';
+import { isCommandAvailable, getNpmExecutablePath } from '../../../utils/osUtils.js';
 import { ExtensionInstaller } from './ExtensionInstaller.js';
 import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 import {
@@ -13,6 +13,8 @@ import {
     MACRO_EXPRESSIONS,
     MacroResolverFunctions
 } from '../../../utils/macroExpressionUtils.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
 
 const execAsync = promisify(exec);
 
@@ -123,7 +125,7 @@ export abstract class BaseClientInstaller {
      */
     protected async handleWindowsNpx(config: any): Promise<any> {
         if (process.platform === 'win32' && config.command === 'npx') {
-            const npmPath = await this.getNpmPath();
+            const npmPath = await getNpmExecutablePath();
             return {
                 ...config,
                 command: 'cmd',
@@ -179,19 +181,6 @@ export abstract class BaseClientInstaller {
         };
     }
 
-    /**
-     * Get the NPM path on Windows
-     */
-    private async getNpmPath(): Promise<string> {
-        try {
-            const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
-            return stdout.trim().replace(/\\npm\.cmd$/, '');
-        } catch (error) {
-            Logger.error('Error getting npm path:', error);
-            return 'C:\\Program Files\\nodejs';
-        }
-    }
-
     /**
      * Checks if VS Code or VS Code Insiders is installed and installs the client extension.
      * @param operationId The operation ID for tracking.
@@ -276,48 +265,73 @@ export abstract class BaseClientInstaller {
      * @param serverConfig Server configuration
      * @param options Installation options including environment variables and arguments
      */
-    async install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus> {
+    async install(serverConfig: McpConfig, options: ServerInstallOptions, categoryName?: string): Promise<OperationStatus> {
         const operationId = this.generateOperationId();
 
-        try {
-            const vsCodeCheckResult = await this.checkVSCodeAndInstallExtension(operationId);
-            if (vsCodeCheckResult) {
-                return vsCodeCheckResult;
-            }
+        const recorder = InstallOperationManager.getInstance(categoryName || serverConfig.name, serverConfig.name);
+        return await recorder.recording(
+            async () => {
+                await recorder.recording(
+                    () => this.checkVSCodeAndInstallExtension(operationId), {
+                    stepName: RecordingConstants.STEP_CHECK_VSCODE_AND_INSTALL_EXTENSION,
+                    onResult: (result) => result?.status !== 'failed'
+                }
+                )
 
-            const installConfig = await this.setupInstallConfig(serverConfig, options);
-            if (serverConfig.mode) {
-                installConfig.mode = serverConfig.mode;
-            }
+                const installConfig = await recorder.recording(
+                    () => this.setupInstallConfig(serverConfig, options), {
+                    stepName: RecordingConstants.STEP_SETUP_INSTALLATION_CONFIG
+                });
 
-            // Update VS Code settings
-            const results = await this.updateVSCodeSettings(serverConfig.name, installConfig);
+                if (serverConfig.mode) {
+                    installConfig.mode = serverConfig.mode;
+                }
 
-            // Determine overall success
-            const anySuccess = results.some(r => r.success);
-            const successPaths = results.filter(r => r.success).map(r => r.path);
-            const errors = results.filter(r => !r.success).map(r => r.error);
+                const results = await recorder.recording(
+                    () => this.updateVSCodeSettings(serverConfig.name, installConfig), {
+                    stepName: RecordingConstants.STEP_UPDATE_VSCODE_SETTINGS,
+                    onResult: (result) => result?.some(r => r.success)
+                }
+                );
 
-            return {
-                status: anySuccess ? 'completed' : 'failed',
-                type: 'install',
-                target: 'server',
-                message: anySuccess
+                // Determine overall success
+                const anySuccess = results.some(r => r.success);
+                const successPaths = results.filter(r => r.success).map(r => r.path);
+                const errors = results.filter(r => !r.success).map(r => r.error);
+
+                const finalMessage = anySuccess
                     ? `Successfully installed ${this.clientName} client. Updated settings in: ${successPaths.join(', ')}`
-                    : `Failed to install ${this.clientName} client. Errors: ${errors.join('; ')}`,
-                operationId,
-                error: anySuccess ? undefined : errors.join('; ')
-            };
-        } catch (error) {
-            return {
-                status: 'failed',
-                type: 'install',
-                target: 'server',
-                message: `Unexpected error installing ${this.clientName} client: ${error instanceof Error ? error.message : String(error)}`,
-                operationId,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
+                    : `Failed to install ${this.clientName} client. Errors: ${errors.join('; ')}`;
+
+                return {
+                    status: anySuccess ? 'completed' : 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: finalMessage,
+                    operationId,
+                    error: anySuccess ? undefined : errors.join('; ')
+                };
+            },
+            {
+                stepName: RecordingConstants.STEP_INSTALLATION,
+                onResult: (result) => result?.status !== 'failed',
+                endMessage: (result) => (result as OperationStatus)?.message,
+                onError: (error) => {
+                    const errorMsg = `Unexpected error installing ${this.clientName} client: ${error instanceof Error ? error.message : String(error)}`;
+                    return {
+                        result: {
+                            status: 'failed',
+                            type: 'install',
+                            target: 'server',
+                            message: errorMsg,
+                            operationId,
+                            error: error instanceof Error ? error.message : String(error)
+                        }, message: errorMsg
+                    };
+                }
+            }
+        );
+
     }
 
     /**

package/src/core/installers/clients/ClientInstaller.ts

@@ -9,6 +9,8 @@ import {
 } from '../../metadatas/types.js';
 import { Logger } from '../../../utils/logger.js';
 import { ClientInstallerFactory } from './ClientInstallerFactory.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import { stat } from 'fs';
 
 /**
  * Main client installer class that orchestrates client installation process
@@ -26,56 +28,27 @@ export class ClientInstaller {
     }
 
     /**
-     * Generate a unique operation ID for tracking installations
-     */
-    private generateOperationId(): string {
-        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-
-    /**
-     * Check if server requirements are ready
-     * Waits for requirements to be ready with timeout
+     * Install all specified clients
      */
-    private async checkRequirements(operationId: string, clientName: string, options: ServerInstallOptions): Promise<boolean> {
-        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
-
-        if (!requirementsReady) {
-            const pendingStatus: OperationStatus = {
-                status: 'pending',
-                type: 'install',
-                target: 'server',
-                message: `Waiting for requirements to be ready for client: ${clientName}`,
-                operationId
-            };
-
-            await this.configProvider.updateServerOperationStatus(
-                this.categoryName,
-                this.serverName,
-                clientName,
-                pendingStatus
-            );
-
-            // Set up periodic checking with timeout
-            const startTime = Date.now();
-            const timeoutMs = 5 * 60 * 1000; // 5 minutes
-            const intervalMs = 5 * 1000; // 5 seconds
-
-            while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
-                await new Promise(resolve => setTimeout(resolve, intervalMs));
-                requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
-            }
-        }
+    async install(options: ServerInstallOptions): Promise<ServerOperationResult> {
+        const initialStatuses: OperationStatus[] = [];
 
-        var requirementsStatus: RequirementStatus[] = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
+        // Start installation for each client asynchronously
+        const installPromises = this.clients.map(async (clientName) => {
+            const status = await this.installClient(clientName, options);
+            initialStatuses.push(status);
+            return status;
+        });
 
-        // Find first non-empty npmPath from requirements status
-        const npmPathRequirement = requirementsStatus.find(status => status.npmPath && status.npmPath.length > 0);
-        if (npmPathRequirement && npmPathRequirement.npmPath) {
-            options.settings = options.settings || {};
-            options.settings.npmPath = npmPathRequirement.npmPath;
-        }
+        // Wait for all installations to complete
+        await Promise.all(installPromises);
 
-        return requirementsReady;
+        // Return result
+        return {
+            success: true,
+            message: 'Client installations completed',
+            status: initialStatuses
+        };
     }
 
     /**
@@ -104,7 +77,41 @@ export class ClientInstaller {
             operationId
         };
 
-        this.processInstallation(clientName, operationId, options);
+        // Async installation process
+        this.processInstallation(clientName, operationId, options)
+            .then((status) => {
+                if (status.status === 'completed' || status.status === 'failed') {
+                    InstallOperationManager
+                        .getInstance(this.categoryName, this.serverName)
+                        .markOverallStatus(status.status)
+                }
+
+                this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    status
+                );
+            })
+            .catch((error) => {
+                this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    {
+                        status: 'failed',
+                        type: 'install',
+                        target: 'server',
+                        message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`,
+                        operationId,
+                        error: error instanceof Error ? error.message : String(error)
+                    }
+                );
+                Logger.error(`Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`);
+                InstallOperationManager
+                    .getInstance(this.categoryName, this.serverName)
+                    .markOverallStatus('failed', error)
+            });
 
         // Update server status with initial client installation status
         await this.configProvider.updateServerOperationStatus(
@@ -116,107 +123,100 @@ export class ClientInstaller {
         return initialStatus;
     }
 
-    private async processInstallation(clientName: string, operationId: string, options: ServerInstallOptions): Promise<void> {
-        try {
-            // Check requirements
-            const requirementsReady = await this.checkRequirements(operationId, clientName, options);
-            if (!requirementsReady) {
-                const failedStatus: OperationStatus = {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: `Requirements not ready for client: ${clientName} after timeout`,
-                    operationId
-                };
-
-                await this.configProvider.updateServerOperationStatus(
-                    this.categoryName,
-                    this.serverName,
-                    clientName,
-                    failedStatus
-                );
-                return;
-            }
+    private async processInstallation(clientName: string, operationId: string, options: ServerInstallOptions): Promise<OperationStatus> {
+        const requirementsReady = await this.checkRequirements(operationId, clientName, options);
+        if (!requirementsReady) {
+            const failedStatus: OperationStatus = {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Requirements not ready for client: ${clientName} after timeout`,
+                operationId
+            };
+            return failedStatus;
+        }
 
-            // Create client-specific installer
-            const installer = ClientInstallerFactory.getInstaller(clientName);
+        // Create client-specific installer
+        const installer = ClientInstallerFactory.getInstaller(clientName);
 
-            if (!installer) {
-                throw new Error(`Failed to create installer for client: ${clientName}`);
-            }
+        if (!installer) {
+            throw new Error(`Failed to create installer for client: ${clientName}`);
+        }
 
-            const serverConfig = await this.configProvider.getServerMcpConfig(this.categoryName, this.serverName);
-            if (!serverConfig) {
-                throw new Error(`Server configuration not found for category: ${this.categoryName}, server: ${this.serverName}`);
-            }
+        const serverConfig = await this.configProvider.getServerMcpConfig(this.categoryName, this.serverName);
+        if (!serverConfig) {
+            throw new Error(`Server configuration not found for category: ${this.categoryName}, server: ${this.serverName}`);
+        }
 
-            // If we've reached here, requirements are ready - update status to in-progress
-            const inProgressStatus: OperationStatus = {
-                status: 'in-progress',
-                type: 'install',
-                target: 'server',
-                message: `Installing client: ${clientName}`,
-                operationId: operationId
-            };
+        // If we've reached here, requirements are ready - update status to in-progress
+        const inProgressStatus: OperationStatus = {
+            status: 'in-progress',
+            type: 'install',
+            target: 'server',
+            message: `Installing client: ${clientName}`,
+            operationId: operationId
+        };
 
-            await this.configProvider.updateServerOperationStatus(
-                this.categoryName,
-                this.serverName,
-                clientName,
-                inProgressStatus
-            );
-            // Install client
-            const status = await installer.install(serverConfig, options);
-            await this.configProvider.updateServerOperationStatus(
-                this.categoryName,
-                this.serverName,
-                clientName,
-                status
-            );
+        await this.configProvider.updateServerOperationStatus(
+            this.categoryName,
+            this.serverName,
+            clientName,
+            inProgressStatus
+        );
+        // Install client
+        return await installer.install(serverConfig, options, this.categoryName);
+    }
 
-            if (status.status === 'completed') {
-                await this.configProvider.reloadClientMCPSettings();
-            }
-        } catch (error) {
-            const errorStatus: OperationStatus = {
-                status: 'failed',
+    /**
+ * Generate a unique operation ID for tracking installations
+ */
+    private generateOperationId(): string {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Check if server requirements are ready
+     * Waits for requirements to be ready with timeout
+     */
+    private async checkRequirements(operationId: string, clientName: string, options: ServerInstallOptions): Promise<boolean> {
+        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+
+        if (!requirementsReady) {
+            const pendingStatus: OperationStatus = {
+                status: 'pending',
                 type: 'install',
                 target: 'server',
-                message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`,
-                operationId,
-                error: error instanceof Error ? error.message : String(error)
+                message: `Waiting for requirements to be ready for client: ${clientName}`,
+                operationId
             };
 
             await this.configProvider.updateServerOperationStatus(
                 this.categoryName,
                 this.serverName,
                 clientName,
-                errorStatus
+                pendingStatus
             );
-        }
-    }
 
-    /**
-     * Install all specified clients
-     */
-    async install(options: ServerInstallOptions): Promise<ServerOperationResult> {
-        const initialStatuses: OperationStatus[] = [];
+            // Set up periodic checking with timeout
+            const startTime = Date.now();
+            const timeoutMs = 5 * 60 * 1000; // 5 minutes
+            const intervalMs = 5 * 1000; // 5 seconds
 
-        // Start installation for each client asynchronously
-        const installPromises = this.clients.map(async (clientName) => {
-            const status = await this.installClient(clientName, options);
-            initialStatuses.push(status);
-            return status;
-        });
+            while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
+                await new Promise(resolve => setTimeout(resolve, intervalMs));
+                requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+            }
+        }
 
-        // Wait for all installations to complete
-        await Promise.all(installPromises);
+        var requirementsStatus: RequirementStatus[] = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
 
-        // Return result
-        return {
-            success: true,
-            message: 'Client installations completed',
-            status: initialStatuses
-        };
+        // Find first non-empty npmPath from requirements status
+        const npmPathRequirement = requirementsStatus.find(status => status.npmPath && status.npmPath.length > 0);
+        if (npmPathRequirement && npmPathRequirement.npmPath) {
+            options.settings = options.settings || {};
+            options.settings.npmPath = npmPathRequirement.npmPath;
+        }
+
+        return requirementsReady;
     }
 }

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

@@ -3,6 +3,7 @@ import path from 'path';
 import { SETTINGS_DIR } from '../../metadatas/constants.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 import { Logger } from '../../../utils/logger.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 
 /**
  * Abstract base class with common functionality for all requirement installers
@@ -18,7 +19,14 @@ export abstract class BaseInstaller implements RequirementInstaller {
 
     abstract canHandle(requirement: RequirementConfig): boolean;
     abstract supportCheckUpdates(): boolean;
-    abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Install the requirement
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation
+     */
+    abstract install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus>;
     abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Get the latest version available for the requirement.