imcp 0.1.1 → 0.1.2

package/dist/cli/index.js

@@ -2,17 +2,7 @@
 import { Command } from 'commander';
 import { createServeCommand } from './commands/serve.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';
-// Custom error interface for Commander.js errors
-// ANSI color codes
-const COLORS = {
-    reset: '\x1b[0m',
-    yellow: '\x1b[33m'
-};
+import { checkForUpdates } from '../utils/versionUtils.js';
 async function main() {
     // Initialize the MCP manager
     // await mcpManager.initialize();
@@ -64,40 +54,6 @@ process.on('unhandledRejection', (error) => {
     }
     process.exit(1);
 });
-/**
- * Check if there's a newer version of the package available
- */
-async function checkForUpdates() {
-    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) => {
     if (error instanceof Error) {

package/dist/core/installers/clients/BaseClientInstaller.d.ts

@@ -40,10 +40,6 @@ export declare abstract class BaseClientInstaller {
      * Override in child classes to provide custom SSE configuration
      */
     protected handleSseMode(settings: any, serverName: string, installConfig: any): void;
-    /**
-     * Get the NPM path on Windows
-     */
-    private getNpmPath;
     /**
      * Checks if VS Code or VS Code Insiders is installed and installs the client extension.
      * @param operationId The operation ID for tracking.
@@ -66,7 +62,7 @@ export declare abstract class BaseClientInstaller {
      * @param serverConfig Server configuration
      * @param options Installation options including environment variables and arguments
      */
-    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    install(serverConfig: McpConfig, options: ServerInstallOptions, categoryName?: string): Promise<OperationStatus>;
     /**
      * Abstract method that must be implemented by client-specific installers
      */

package/dist/core/installers/clients/BaseClientInstaller.js

@@ -1,10 +1,12 @@
 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 { MACRO_EXPRESSIONS, MacroResolverFunctions } from '../../../utils/macroExpressionUtils.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
 const execAsync = promisify(exec);
 /**
  * Base class for client installers with shared functionality
@@ -96,7 +98,7 @@ export class BaseClientInstaller {
      */
     async handleWindowsNpx(config) {
         if (process.platform === 'win32' && config.command === 'npx') {
-            const npmPath = await this.getNpmPath();
+            const npmPath = await getNpmExecutablePath();
             return {
                 ...config,
                 command: 'cmd',
@@ -146,19 +148,6 @@ export class BaseClientInstaller {
             url: installConfig.url
         };
     }
-    /**
-     * Get the NPM path on Windows
-     */
-    async getNpmPath() {
-        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.
@@ -238,44 +227,57 @@ export class BaseClientInstaller {
      * @param serverConfig Server configuration
      * @param options Installation options including environment variables and arguments
      */
-    async install(serverConfig, options) {
+    async install(serverConfig, options, categoryName) {
         const operationId = this.generateOperationId();
-        try {
-            const vsCodeCheckResult = await this.checkVSCodeAndInstallExtension(operationId);
-            if (vsCodeCheckResult) {
-                return vsCodeCheckResult;
-            }
-            const installConfig = await this.setupInstallConfig(serverConfig, options);
+        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 recorder.recording(() => this.setupInstallConfig(serverConfig, options), {
+                stepName: RecordingConstants.STEP_SETUP_INSTALLATION_CONFIG
+            });
             if (serverConfig.mode) {
                 installConfig.mode = serverConfig.mode;
             }
-            // Update VS Code settings
-            const results = await this.updateVSCodeSettings(serverConfig.name, installConfig);
+            const results = await recorder.recording(() => this.updateVSCodeSettings(serverConfig.name, installConfig), {
+                stepName: RecordingConstants.STEP_UPDATE_VSCODE_SETTINGS,
+                onResult: (result) => result?.some(r => r.success)
+            });
             // 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('; ')}`;
             return {
                 status: anySuccess ? 'completed' : 'failed',
                 type: 'install',
                 target: 'server',
-                message: anySuccess
-                    ? `Successfully installed ${this.clientName} client. Updated settings in: ${successPaths.join(', ')}`
-                    : `Failed to install ${this.clientName} client. Errors: ${errors.join('; ')}`,
+                message: finalMessage,
                 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)
-            };
-        }
+        }, {
+            stepName: RecordingConstants.STEP_INSTALLATION,
+            onResult: (result) => result?.status !== 'failed',
+            endMessage: (result) => result?.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
+                };
+            }
+        });
     }
 }
 //# sourceMappingURL=BaseClientInstaller.js.map

package/dist/core/installers/clients/ClientInstaller.d.ts

@@ -10,21 +10,21 @@ export declare class ClientInstaller {
     private configProvider;
     constructor(categoryName: string, serverName: string, clients: string[]);
     /**
-     * Generate a unique operation ID for tracking installations
-     */
-    private generateOperationId;
-    /**
-     * Check if server requirements are ready
-     * Waits for requirements to be ready with timeout
+     * Install all specified clients
      */
-    private checkRequirements;
+    install(options: ServerInstallOptions): Promise<ServerOperationResult>;
     /**
      * Install client with requirements checking
      */
     private installClient;
     private processInstallation;
     /**
-     * Install all specified clients
+ * Generate a unique operation ID for tracking installations
+ */
+    private generateOperationId;
+    /**
+     * Check if server requirements are ready
+     * Waits for requirements to be ready with timeout
      */
-    install(options: ServerInstallOptions): Promise<ServerOperationResult>;
+    private checkRequirements;
 }

package/dist/core/installers/clients/ClientInstaller.js

@@ -1,5 +1,7 @@
 import { ConfigurationProvider } from '../../loaders/ConfigurationProvider.js';
+import { Logger } from '../../../utils/logger.js';
 import { ClientInstallerFactory } from './ClientInstallerFactory.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 /**
  * Main client installer class that orchestrates client installation process
  * Handles requirements checking and delegates to specific client installers
@@ -16,43 +18,24 @@ export class ClientInstaller {
         this.configProvider = ConfigurationProvider.getInstance();
     }
     /**
-     * Generate a unique operation ID for tracking installations
-     */
-    generateOperationId() {
-        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
      */
-    async checkRequirements(operationId, clientName, options) {
-        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
-        if (!requirementsReady) {
-            const pendingStatus = {
-                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);
-            }
-        }
-        var requirementsStatus = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
-        // 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;
+    async install(options) {
+        const initialStatuses = [];
+        // 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;
+        });
+        // Wait for all installations to complete
+        await Promise.all(installPromises);
+        // Return result
+        return {
+            success: true,
+            message: 'Client installations completed',
+            status: initialStatuses
+        };
     }
     /**
      * Install client with requirements checking
@@ -77,82 +60,105 @@ export class ClientInstaller {
             message: `Initializing installation for client: ${clientName}`,
             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(this.categoryName, this.serverName, clientName, initialStatus);
         return initialStatus;
     }
     async processInstallation(clientName, operationId, options) {
-        try {
-            // Check requirements
-            const requirementsReady = await this.checkRequirements(operationId, clientName, options);
-            if (!requirementsReady) {
-                const failedStatus = {
-                    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;
-            }
-            // Create client-specific installer
-            const installer = ClientInstallerFactory.getInstaller(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}`);
-            }
-            // If we've reached here, requirements are ready - update status to in-progress
-            const inProgressStatus = {
-                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);
-            if (status.status === 'completed') {
-                await this.configProvider.reloadClientMCPSettings();
-            }
-        }
-        catch (error) {
-            const errorStatus = {
+        const requirementsReady = await this.checkRequirements(operationId, clientName, options);
+        if (!requirementsReady) {
+            const failedStatus = {
                 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)
+                message: `Requirements not ready for client: ${clientName} after timeout`,
+                operationId
             };
-            await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, errorStatus);
+            return failedStatus;
+        }
+        // Create client-specific installer
+        const installer = ClientInstallerFactory.getInstaller(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}`);
+        }
+        // If we've reached here, requirements are ready - update status to in-progress
+        const inProgressStatus = {
+            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
+        return await installer.install(serverConfig, options, this.categoryName);
     }
     /**
-     * Install all specified clients
+ * Generate a unique operation ID for tracking installations
+ */
+    generateOperationId() {
+        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
      */
-    async install(options) {
-        const initialStatuses = [];
-        // 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;
-        });
-        // Wait for all installations to complete
-        await Promise.all(installPromises);
-        // Return result
-        return {
-            success: true,
-            message: 'Client installations completed',
-            status: initialStatuses
-        };
+    async checkRequirements(operationId, clientName, options) {
+        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+        if (!requirementsReady) {
+            const pendingStatus = {
+                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);
+            }
+        }
+        var requirementsStatus = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
+        // 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;
     }
 }
 //# sourceMappingURL=ClientInstaller.js.map

package/dist/core/installers/requirements/BaseInstaller.d.ts

@@ -1,5 +1,6 @@
 import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 /**
  * Abstract base class with common functionality for all requirement installers
  */
@@ -15,7 +16,14 @@ export declare 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.

package/dist/core/installers/requirements/CommandInstaller.d.ts

@@ -1,5 +1,6 @@
 import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 /**
  * Installer implementation for command-line tools
  */
@@ -38,5 +39,12 @@ export declare class CommandInstaller extends BaseInstaller {
      * @param requirement The requirement to install
      * @returns The status of the installation
      */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    /**
+     * Install the command
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation
+     */
+    install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus>;
 }

package/dist/core/installers/requirements/CommandInstaller.js

@@ -2,6 +2,7 @@ import { OSType } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 import { getOSType, refreshPathEnv } from '../../../utils/osUtils.js';
 import { Logger } from '../../../utils/logger.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
 /**
  * Installer implementation for command-line tools
  */
@@ -122,8 +123,15 @@ export class CommandInstaller extends BaseInstaller {
      * @param requirement The requirement to install
      * @returns The status of the installation
      */
-    async install(requirement) {
-        try {
+    /**
+     * Install the command
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation
+     */
+    async install(requirement, recorder, options) {
+        const doInstall = async () => {
             const status = await this.checkInstallation(requirement);
             if (status.installed) {
                 return status;
@@ -132,20 +140,20 @@ export class CommandInstaller extends BaseInstaller {
             const osType = getOSType();
             let installCommand;
             if (osType === OSType.Windows) {
-                // Windows installation using winget
                 installCommand = `winget install --id ${packageId}`;
                 if (requirement.version && requirement.version !== 'latest') {
                     installCommand += ` --version ${requirement.version}`;
                 }
             }
             else if (osType === OSType.MacOS) {
-                // macOS installation using Homebrew
                 installCommand = `brew install ${packageId}`;
                 if (requirement.version && requirement.version !== 'latest') {
                     installCommand += `@${requirement.version}`;
                 }
             }
             else {
+                if (recorder)
+                    await recorder.recordStep('CommandInstaller:UnsupportedOS', 'failed', `Unsupported OS for ${requirement.name}`);
                 throw new Error(`Unsupported operating system for installing ${requirement.name}`);
             }
             // Execute the installation command
@@ -165,15 +173,41 @@ export class CommandInstaller extends BaseInstaller {
                 version: updatedStatus.version || requirement.version,
                 inProgress: false
             };
+        };
+        if (recorder) {
+            return recorder.recording(doInstall, {
+                stepName: RecordingConstants.STEP_COMMAND_INSTALLER_INSTALL,
+                inProgressMessage: `Installing command: ${requirement.name}`,
+                endMessage: (result) => result.installed
+                    ? `Install completed for ${requirement.name}`
+                    : `Install failed for ${requirement.name}`,
+                onError: (error) => {
+                    return {
+                        result: {
+                            name: requirement.name,
+                            type: 'command',
+                            installed: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            inProgress: false,
+                        },
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                },
+            });
         }
-        catch (error) {
-            return {
-                name: requirement.name,
-                type: 'command',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
+        else {
+            try {
+                return await doInstall();
+            }
+            catch (error) {
+                return {
+                    name: requirement.name,
+                    type: 'command',
+                    installed: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    inProgress: false,
+                };
+            }
         }
     }
 }

package/dist/core/installers/requirements/GeneralInstaller.d.ts

@@ -1,5 +1,6 @@
 import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
 /**
  * Installer implementation for general requirements (type 'other')
  * This installer handles requirements that don't fit into specific package manager categories
@@ -34,5 +35,14 @@ export declare class GeneralInstaller extends BaseInstaller {
      * @param requirement The requirement to install
      * @returns The status of the installation, including the install path in updateInfo
      */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    /**
+     * Install the general requirement
+     * For type 'other', this doesn't actually install anything, but downloads
+     * or locates the asset and returns the path for the caller to use
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation, including the install path in updateInfo
+     */
+    install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus>;
 }