imcp 0.0.3 → 0.0.5

package/src/core/InstallationService.ts

@@ -14,8 +14,9 @@ import {
 } from './types.js';
 import { RequirementInstaller, InstallerFactory, createInstallerFactory } from './installers/index.js';
 import { SUPPORTED_CLIENTS } from './constants.js';
-import { ClientInstaller } from './installers/ClientInstaller.js';
+import { ClientInstaller } from './installers/clients/ClientInstaller.js';
 import { ConfigurationProvider } from './ConfigurationProvider.js';
+import { Logger } from '../utils/logger.js';
 
 const execPromise = util.promisify(exec);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -23,7 +24,6 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 /**
  * Handles the actual installation process for an MCP server.
  */
-
 export class InstallationService {
   private activeInstallations: Map<string, OperationStatus> = new Map();
   private installerFactory: InstallerFactory;
@@ -36,7 +36,6 @@ export class InstallationService {
     return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
   }
 
-
   /**
    * Installs a server based on the provided options and feed configuration.
    * @param serverName The name of the server to install.
@@ -75,101 +74,9 @@ export class InstallationService {
     // Create new ClientInstaller instance for handling installation
     const clientInstaller = new ClientInstaller(categoryName, serverName, clients);
 
-    // Check requirements readiness
-    const requirementsReady = await configProvider.isRequirementsReady(categoryName, serverName);
-    if (!requirementsReady) {
-      // Get feed configuration to get requirements
-      const feedConfig = await configProvider.getFeedConfiguration(categoryName);
-      if (!feedConfig) {
-        return {
-          success: false,
-          message: 'Feed configuration not found',
-          status: [{
-            status: 'failed',
-            type: 'install',
-            target: 'server',
-            message: 'Feed configuration not found'
-          }]
-        };
-      }
-
-      // Find server config
-      const serverConfig = feedConfig.mcpServers.find((s: McpConfig) => s.name === serverName);
-      if (!serverConfig?.dependencies?.requirements) {
-        return {
-          success: false,
-          message: 'Server configuration or requirements not found',
-          status: [{
-            status: 'failed',
-            type: 'install',
-            target: 'server',
-            message: 'Server configuration or requirements not found'
-          }]
-        };
-      }
-
-      // Install requirements asynchronously
-      for (const requirement of serverConfig.dependencies.requirements) {
-        // Create full RequirementConfig from dependency requirement
-
-        const feeds = await configProvider.getFeedConfiguration(categoryName);
-        const requirementConfig = feeds?.requirements?.find((r: RequirementConfig) => r.name === requirement.name) || {
-          name: requirement.name,
-          version: requirement.version,
-          type: 'npm' // Default to npm, can be enhanced to determine from requirement or config
-        };
-
-        const installer = this.installerFactory.getInstaller(requirementConfig);
-        if (!installer) {
-          await configProvider.updateRequirementStatus(categoryName, requirement.name, {
-            name: requirement.name,
-            type: requirementConfig.type,
-            installed: false,
-            error: `No installer found for requirement type: ${requirementConfig.type}`,
-            operationStatus: {
-              status: 'failed',
-              type: 'install',
-              target: 'requirement',
-              message: `No installer found for requirement type: ${requirementConfig.type}`,
-              operationId: this.generateOperationId()
-            }
-          });
-          continue;
-        }
-
-        // Create operation status for requirement
-        const operationStatus: OperationStatus = {
-          status: 'pending',
-          type: 'install',
-          target: 'requirement',
-          message: `Installing requirement: ${requirement.name}`,
-          operationId: this.generateOperationId()
-        };
-
-        // Update requirement status
-        await configProvider.updateRequirementStatus(categoryName, requirement.name, {
-          name: requirement.name,
-          type: requirementConfig.type,
-          installed: false,
-          inProgress: true,
-          operationStatus
-        });
-
-        // Start async installation
-        installer.install(requirementConfig).then(async (installStatus) => {
-          const status: RequirementStatus = {
-            ...installStatus,
-            operationStatus: {
-              status: installStatus.installed ? 'completed' : 'failed',
-              type: 'install',
-              target: 'requirement',
-              message: installStatus.installed ? `Requirement ${requirement.name} installed successfully` : `Failed to install ${requirement.name}`,
-              operationId: operationStatus.operationId
-            }
-          };
-          await configProvider.updateRequirementStatus(categoryName, requirement.name, status);
-        });
-      }
+    const requirementsResult = await this.checkAndInstallRequirements(categoryName, serverName, options);
+    if (requirementsResult) {
+      return requirementsResult;
     }
 
     // Process client installation regardless of requirements state
@@ -230,9 +137,9 @@ export class InstallationService {
           // Update requirement status to indicate update in progress
           await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
             ...currentStatus,
-            name: reqToUpdate.name, // Ensure name is included
-            type: currentStatus.type || 'unknown', // Ensure type is included
-            installed: currentStatus.installed || false, // Ensure installed is included
+            name: reqToUpdate.name,
+            type: currentStatus.type || 'unknown',
+            installed: currentStatus.installed || false,
             inProgress: true,
             operationStatus: {
               status: 'in-progress',
@@ -254,9 +161,9 @@ export class InstallationService {
           // Update requirement status
           await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
             ...updatedStatus,
-            name: reqToUpdate.name, // Ensure name is always included
-            type: updatedStatus.type || currentStatus.type || 'unknown', // Ensure type is included
-            installed: updatedStatus.installed, // This should be defined from updatedStatus
+            name: reqToUpdate.name,
+            type: updatedStatus.type || currentStatus.type || 'unknown',
+            installed: updatedStatus.installed,
             inProgress: false,
             operationStatus: {
               status: updatedStatus.installed ? 'completed' : 'failed',
@@ -266,7 +173,6 @@ export class InstallationService {
                 ? `Successfully updated ${reqToUpdate.name} to version ${reqToUpdate.version}`
                 : `Failed to update ${reqToUpdate.name} to version ${reqToUpdate.version}`
             },
-            // Clear availableUpdate if update was successful
             availableUpdate: updatedStatus.installed ? undefined : currentStatus.availableUpdate
           });
 
@@ -298,7 +204,135 @@ export class InstallationService {
       await updateCheckTracker.endOperation(operationKey);
     }
   }
+
+  /**
+   * Checks and installs requirements for a server if needed
+   * @param categoryName The category name
+   * @param serverName The server name
+   * @param options The installation options
+   * @returns A failure result if requirements check fails, null if requirements are satisfied
+   */
+  private async checkAndInstallRequirements(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult | null> {
+    const configProvider = ConfigurationProvider.getInstance();
+
+    // Get feed configuration to get requirements
+    const feedConfig = await configProvider.getFeedConfiguration(categoryName);
+    if (!feedConfig) {
+      return {
+        success: false,
+        message: 'Feed configuration not found',
+        status: [{
+          status: 'failed',
+          type: 'install',
+          target: 'server',
+          message: 'Feed configuration not found'
+        }]
+      };
+    }
+
+    // Find server config and verify requirements
+    const serverConfig = feedConfig.mcpServers.find((s: McpConfig) => s.name === serverName);
+    if (!serverConfig?.dependencies?.requirements) {
+      Logger.debug(`No requirements for ${serverName}`);
+      return null;
+    }
+
+    // Check all requirements installation status
+    const requirementStatuses = await Promise.all(
+      serverConfig.dependencies.requirements.map(async (req) => {
+        const reqConfig = feedConfig.requirements?.find((r: RequirementConfig) => r.name === req.name) || {
+          name: req.name,
+          version: req.version,
+          type: 'npm'
+        };
+        return await this.installerFactory.checkInstallation(reqConfig, options);
+      })
+    );
+
+    // If all requirements are installed and ready, no need to proceed with installation
+    if (requirementStatuses.every(status => status.installed)) {
+      // Check if requirements are ready via ConfigurationProvider
+      const requirementsReady = await configProvider.isRequirementsReady(categoryName, serverName);
+
+      // Update requirement status if not ready
+      if (!requirementsReady) {
+        for (const status of requirementStatuses) {
+          await configProvider.updateRequirementStatus(categoryName, status.name, status);
+        }
+      }
+      return null;
+    }
+
+    // Sort requirements by order for installation
+    const sortedRequirements = [...serverConfig.dependencies.requirements].sort((a, b) => {
+      const orderA = a.order ?? Infinity;
+      const orderB = b.order ?? Infinity;
+      return orderA - orderB;
+    });
+
+    // Chain installations in sequence while keeping them non-blocking
+    await sortedRequirements.reduce((chain, requirement) => {
+      return chain.then(async () => {
+        const feeds = await configProvider.getFeedConfiguration(categoryName);
+        const requirementConfig = feeds?.requirements?.find((r: RequirementConfig) => r.name === requirement.name) || {
+          name: requirement.name,
+          version: requirement.version,
+          type: 'npm'
+        };
+
+        const installer = this.installerFactory.getInstaller(requirementConfig);
+        if (!installer) {
+          await configProvider.updateRequirementStatus(categoryName, requirement.name, {
+            name: requirement.name,
+            type: requirementConfig.type,
+            installed: false,
+            error: `No installer found for requirement type: ${requirementConfig.type}`,
+            operationStatus: {
+              status: 'failed',
+              type: 'install',
+              target: 'requirement',
+              message: `No installer found for requirement type: ${requirementConfig.type}`,
+              operationId: this.generateOperationId()
+            }
+          });
+          return;
+        }
+
+        const operationStatus: OperationStatus = {
+          status: 'pending',
+          type: 'install',
+          target: 'requirement',
+          message: `Installing requirement: ${requirement.name}`,
+          operationId: this.generateOperationId()
+        };
+
+        await configProvider.updateRequirementStatus(categoryName, requirement.name, {
+          name: requirement.name,
+          type: requirementConfig.type,
+          installed: false,
+          inProgress: true,
+          operationStatus
+        });
+
+        return installer.install(requirementConfig, options).then(async (installStatus) => {
+          const status: RequirementStatus = {
+            ...installStatus,
+            operationStatus: {
+              status: installStatus.installed ? 'completed' : 'failed',
+              type: 'install',
+              target: 'requirement',
+              message: installStatus.installed ? `Requirement ${requirement.name} installed successfully` : `Failed to install ${requirement.name}`,
+              operationId: operationStatus.operationId
+            }
+          };
+          await configProvider.updateRequirementStatus(categoryName, requirement.name, status);
+        });
+      });
+    }, Promise.resolve());
+
+    return null;
+  }
 }
 
 // Export a singleton instance (optional)
-// export const installationService = new InstallationService();
+// export const installationService = new InstallationService();

package/src/core/RequirementService.ts

@@ -54,25 +54,20 @@ export class RequirementService {
      * @param requirement The requirement to check for updates
      * @returns Updated status with available updates information
      */
-    public async checkRequirementForUpdates(requirement: RequirementConfig): Promise<RequirementStatus> {
+    public async checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus> {
         // Validate requirement
         this.validateRequirement(requirement);
 
         // Get current status
-        const status = await this.checkRequirementStatus(requirement);
 
         // Check for updates using the appropriate installer
         const installer = this.installerFactory.getInstaller(requirement);
-        if (!installer) {
-            return status;
-        }
-
-        // If the installer supports update checking, use it
-        if ('checkForUpdates' in installer) {
-            return await (installer as any).checkForUpdates(requirement, status);
+        if (!installer || !installer.supportCheckUpdates()) {
+            return currentStatus;
         }
 
-        return status;
+        const status = await this.checkRequirementStatus(requirement);
+        return await (installer as any).checkForUpdates(requirement, status);
     }
 
     /**

package/src/core/constants.ts

@@ -60,14 +60,28 @@ const CODE_INSIDER_STRORAGE_DIR = (() => {
  */
 export const SUPPORTED_CLIENTS: Record<string, any> = {
   'MSRooCode': { /* MSROO specific settings */
+
+    extension: {
+      extensionId: 'microsoftai.ms-roo-cline',
+      leastVersion: '0.0.8',
+      repository: 'ai-microsoft/roo-cline',
+      assetName: 'ms-roo-cline-${version}.vsix',
+      private: true
+    },
     codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
-    codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-clinev', 'settings', 'cline_mcp_settings.json'),
+    codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
   },
   'Cline': { /* VS Code specific settings */
+    extension: {
+      extensionId: 'saoudrizwan.claude-dev',
+    },
     codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
     codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
   },
   'GithubCopilot': { /* GitHub Copilot specific settings */
+    extension: {
+      extensionId: 'github.copilot',
+    },
     codeSettingPath: path.join(CODE_STRORAGE_DIR, 'settings.json'),
     codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'settings.json'),
   },