imcp 0.0.3 → 0.0.5

package/dist/core/InstallationService.js

@@ -4,8 +4,9 @@ import { exec } from 'child_process';
 import util from 'util';
 import { 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));
 /**
@@ -54,94 +55,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) => 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) => 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 = {
-                    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 = {
-                        ...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
         // Each client installer will check requirements before actual installation
@@ -191,9 +107,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',
@@ -212,9 +128,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',
@@ -224,7 +140,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
                     });
                     console.log(`Requirement ${reqToUpdate.name} updated to version ${reqToUpdate.version}`);
@@ -255,6 +170,119 @@ 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
+     */
+    async checkAndInstallRequirements(categoryName, serverName, options) {
+        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) => 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) => 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) => 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 = {
+                    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 = {
+                        ...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();

package/dist/core/RequirementService.d.ts

@@ -28,7 +28,7 @@ export declare class RequirementService {
      * @param requirement The requirement to check for updates
      * @returns Updated status with available updates information
      */
-    checkRequirementForUpdates(requirement: RequirementConfig): Promise<RequirementStatus>;
+    checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
     /**
      * Update a requirement to a new version
      * @param requirement The requirement configuration

package/dist/core/RequirementService.js

@@ -45,21 +45,17 @@ export class RequirementService {
      * @param requirement The requirement to check for updates
      * @returns Updated status with available updates information
      */
-    async checkRequirementForUpdates(requirement) {
+    async checkRequirementForUpdates(requirement, currentStatus) {
         // 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.checkForUpdates(requirement, status);
+        if (!installer || !installer.supportCheckUpdates()) {
+            return currentStatus;
         }
-        return status;
+        const status = await this.checkRequirementStatus(requirement);
+        return await installer.checkForUpdates(requirement, status);
     }
     /**
      * Update a requirement to a new version

package/dist/core/constants.js

@@ -53,14 +53,27 @@ const CODE_INSIDER_STRORAGE_DIR = (() => {
  */
 export const SUPPORTED_CLIENTS = {
     'MSRooCode': {
+        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': {
+        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': {
+        extension: {
+            extensionId: 'github.copilot',
+        },
         codeSettingPath: path.join(CODE_STRORAGE_DIR, 'settings.json'),
         codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'settings.json'),
     },

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

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, RegistryConfig } from '../types.js';
+import { RequirementConfig, RequirementStatus, RegistryConfig, ServerInstallOptions } from '../types.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 /**
  * Abstract base class with common functionality for all requirement installers
@@ -14,8 +14,9 @@ export declare abstract class BaseInstaller implements RequirementInstaller {
         stderr: string;
     }>);
     abstract canHandle(requirement: RequirementConfig): boolean;
-    abstract install(requirement: RequirementConfig): Promise<RequirementStatus>;
-    abstract checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    abstract supportCheckUpdates(): boolean;
+    abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Check if updates are available for the requirement
      * @param requirement The requirement to check
@@ -69,5 +70,5 @@ export declare abstract class BaseInstaller implements RequirementInstaller {
      * @param packageName The name of the pip package
      * @returns The latest version
      */
-    protected getPipLatestVersion(packageName: string): Promise<string>;
+    protected getPipLatestVersion(packageName: string, options?: ServerInstallOptions): Promise<string>;
 }

package/dist/core/installers/BaseInstaller.js

@@ -96,31 +96,19 @@ export class BaseInstaller {
         let resolvedAssetsName = assetsName || '';
         const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
         const latestTag = stdout.trim();
-        // Handle latest version detection
-        if (version.includes('${latest}') || version === 'latest') {
-            let latestVersion = latestTag;
-            if (latestVersion.startsWith('v') && version.startsWith('v')) {
-                latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
-                // Replace ${latest} in version and asset names
-                version = version.replace('${latest}', latestVersion);
-                if (assetsName) {
-                    resolvedAssetsName = assetsName.replace('${latest}', latestVersion).replace('${version}', version);
-                }
-                if (assetName) {
-                    resolvedAssetName = assetName.replace('${latest}', latestVersion).replace('${version}', version);
-                }
-            }
-        }
-        else {
-            if (assetsName) {
-                resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
-            }
-            if (assetName) {
-                resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
-            }
-            Logger.debug(`Downloading ${requirement.name} from GitHub release ${repository} version ${version}`);
-            Logger.debug(`ResolvedAssetsName} ${resolvedAssetName}; ResolvedAsetName} ${resolvedAssetName}`);
-        }
+        let latestVersion = latestTag;
+        const tagWithVPrefix = latestVersion.startsWith('v');
+        if (tagWithVPrefix)
+            latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
+        version = version.includes("latest") ? latestVersion : version;
+        if (assetsName) {
+            resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
+        }
+        if (assetName) {
+            resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
+        }
+        Logger.debug(`Downloading ${requirement.name} from GitHub release ${repository} version ${version}`);
+        Logger.debug(`ResolvedAssetsName} ${resolvedAssetName}; ResolvedAsetName} ${resolvedAssetName}`);
         const pattern = resolvedAssetsName ? resolvedAssetsName : resolvedAssetName;
         Logger.debug(`Resolved pattern: ${pattern}`);
         if (!pattern) {
@@ -129,7 +117,7 @@ export class BaseInstaller {
         // Download the release asset
         const downloadPath = path.join(this.downloadsDir, path.basename(pattern));
         if (!await this.fileExists(downloadPath)) {
-            await this.execPromise(`gh release download ${version.startsWith('v') ? version : `v${version}`} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
+            await this.execPromise(`gh release download ${tagWithVPrefix ? `v${version}` : version} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
         }
         // Handle zip file extraction if the downloaded file is a zip
         if (downloadPath.endsWith('.zip')) {
@@ -256,8 +244,9 @@ export class BaseInstaller {
      * @param packageName The name of the pip package
      * @returns The latest version
      */
-    async getPipLatestVersion(packageName) {
-        const { stdout } = await this.execPromise(`pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
+    async getPipLatestVersion(packageName, options) {
+        const pythonCmd = options?.settings?.pythonEnv || 'python';
+        const { stdout } = await this.execPromise(`${pythonCmd} -m pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
         return stdout.trim();
     }
 }