imcp 0.0.19 → 0.1.2

package/.roo/rules-code/rules.md

@@ -0,0 +1,88 @@
+*IMPORTANT* Before I attempt to complete a task with code changes, I MUST have to ask confirmation with user whether to update memory bank
+
+memory*bank_strategy:
+initialization: |
+<thinking> - **CHECK FOR MEMORY BANK:**
+</thinking>
+<thinking>
+* First, check if the memory-bank/ directory exists.
+</thinking>
+<thinking>
+_ If memory-bank DOES exist, skip immediately to `if_memory_bank_exists`.
+</thinking>
+if_no_memory_bank: | 1. **Inform the User:**  
+ "No Memory Bank was found. I recommend creating one to maintain project context. Would you like to switch to Flow-Architect mode to do this?" 2. **Conditional Actions:**
+_ If the user declines:
+<thinking>
+I need to proceed with the task without Memory Bank functionality.
+</thinking>
+a. Inform the user that the Memory Bank will not be created.
+b. Set the status to '[MEMORY BANK: INACTIVE]'.
+c. Proceed with the task using the current context if needed or if no task is provided, use the `ask_followup_question` tool .
+_ If the user agrees:
+Switch to Flow-Architect mode to create the Memory Bank.
+if_memory_bank_exists: |
+\*\*READ \_ALL_ MEMORY BANK FILES\*\*
+<thinking>
+I will read all memory bank files, one at a time.
+</thinking>
+Plan: Read all mandatory files sequentially. 1. Read `productContext.md` 2. Read `activeContext.md` 3. Read `systemPatterns.md` 4. Read `decisionLog.md` 5. Read `progress.md` 6. Set status to [MEMORY BANK: ACTIVE] and inform user. 7. Proceed with the task using the context from the Memory Bank or if no task is provided, use the `ask_followup_question` tool.
+
+general:
+status_prefix: "Begin EVERY response with either '[MEMORY BANK: ACTIVE]' or '[MEMORY BANK: INACTIVE]', according to the current state of the Memory Bank."
+
+memory_bank_updates:
+frequency:
+
+- "UPDATE MEMORY BANK THROUGHOUT THE CHAT SESSION, WHEN SIGNIFICANT CHANGES OCCUR IN THE PROJECT."
+  decisionLog.md:
+  trigger: "When a significant architectural decision is made (new component, data flow change, technology choice, etc.). Use your judgment to determine significance."
+  action: |
+  <thinking>
+  I need to update decisionLog.md with a decision, the rationale, and any implications.
+  </thinking>
+  Use insert*content to \_append* new information. Never overwrite existing entries. Always include a timestamp.  
+   format: |
+  "[YYYY-MM-DD HH:MM:SS] - [Summary of Change/Focus/Issue]"
+  productContext.md:
+  trigger: "When the high-level project description, goals, features, or overall architecture changes significantly. Use your judgment to determine significance."
+  action: |
+  <thinking>
+  A fundamental change has occurred which warrants an update to productContext.md.
+  </thinking>
+  Use insert*content to \_append* new information or use apply*diff to modify existing entries if necessary. Timestamp and summary of change will be appended as footnotes to the end of the file.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Summary of Change]"
+  systemPatterns.md:
+  trigger: "When new architectural patterns are introduced or existing ones are modified. Use your judgement."
+  action: |
+  <thinking>
+  I need to update systemPatterns.md with a brief summary and time stamp.
+  </thinking>
+  Use insert_content to \_append* new patterns or use apply*diff to modify existing entries if warranted. Always include a timestamp.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Description of Pattern/Change]"
+  activeContext.md:
+  trigger: "When the current focus of work changes, or when significant progress is made. Use your judgement."
+  action: |
+  <thinking>
+  I need to update activeContext.md with a brief summary and time stamp.
+  </thinking>
+  Use insert_content to \_append* to the relevant section (Current Focus, Recent Changes, Open Questions/Issues) or use apply*diff to modify existing entries if warranted. Always include a timestamp.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Summary of Change/Focus/Issue]"
+  progress.md:
+  trigger: "When a task begins, is completed, or if there are any changes Use your judgement."
+  action: |
+  <thinking>
+  I need to update progress.md with a brief summary and time stamp.
+  </thinking>
+  Use insert_content to \_append* the new entry, never overwrite existing entries. Always include a timestamp.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Summary of Change/Focus/Issue]"
+
+umb:
+trigger: "^(Update Memory Bank|UMB)$"
+instructions: - "Halt Current Task: Stop current activity" - "Acknowledge Command: '[MEMORY BANK: UPDATING]'" - "Review Chat History"
+core_update_process: | 1. Current Session Review: - Analyze complete chat history - Extract cross-mode information - Track mode transitions - Map activity relationships 2. Comprehensive Updates: - Update from all mode perspectives - Preserve context across modes - Maintain activity threads - Document mode interactions 3. Memory Bank Synchronization: - Update all affected *.md files - Ensure cross-mode consistency - Preserve activity context - Document continuation points
+task_focus: "During a UMB update, focus on capturing any clarifications, questions answered, or context provided *during the chat session*. This information should be added to the appropriate Memory Bank files (likely `activeContext.md` or `decisionLog.md`), using the other modes' update formats as a guide. *Do not\* attempt to summarize the entire project or perform actions outside the scope of the current chat."
+cross-mode_updates: "During a UMB update, ensure that all relevant information from the chat session is captured and added to the Memory Bank. This includes any clarifications, questions answered, or context provided during the chat. Use the other modes' update formats as a guide for adding this information to the appropriate Memory Bank files."
+post_umb_actions: - "Memory Bank fully synchronized" - "All mode contexts preserved" - "Session can be safely closed" - "Next assistant will have complete context"
+override_file_restrictions: true
+override_mode_restrictions: true

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>;
 }