imcp 0.0.12 → 0.0.14

package/dist/core/ConfigurationProvider.d.ts

@@ -1,4 +1,4 @@
-import { MCPServerCategory, FeedConfiguration, InstallationStatus, RequirementStatus, MCPServerStatus, OperationStatus } from './types.js';
+import { MCPServerCategory, FeedConfiguration, InstallationStatus, RequirementStatus, MCPServerStatus, OperationStatus, McpConfig } from './types.js';
 export declare class ConfigurationProvider {
     private static instance;
     private configPath;
@@ -14,6 +14,7 @@ export declare class ConfigurationProvider {
     getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;
     getClientMcpSettings(): Promise<Record<string, Record<string, any>> | undefined>;
     getFeedConfiguration(categoryName: string): Promise<FeedConfiguration | undefined>;
+    getServerMcpConfig(categoryName: string, serverName: string): Promise<McpConfig | undefined>;
     getInstallationStatus(categoryName: string): Promise<InstallationStatus | undefined>;
     getServerStatus(categoryName: string, serverName: string): Promise<MCPServerStatus | undefined>;
     getRequirementStatus(categoryName: string, requirementName: string): Promise<RequirementStatus | undefined>;

package/dist/core/ConfigurationProvider.js

@@ -94,6 +94,11 @@ export class ConfigurationProvider {
             return this.configuration.feeds[categoryName];
         });
     }
+    async getServerMcpConfig(categoryName, serverName) {
+        return await this.withLock(async () => {
+            return this.configuration.feeds[categoryName]?.mcpServers.find(s => s.name === serverName);
+        });
+    }
     async getInstallationStatus(categoryName) {
         return await this.withLock(async () => {
             // Inline getServerCategory logic
@@ -241,35 +246,26 @@ export class ConfigurationProvider {
                 });
                 await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
                 await fs.mkdir(this.tempDir, { recursive: true });
-                try {
-                    await fs.access(path.join(this.tempDir, '.git'));
-                    Logger.debug('Found existing repository, updating...');
-                    const { stdout, stderr } = await execAsync('git pull', { cwd: this.tempDir });
-                    Logger.debug({
-                        action: 'git_pull',
-                        stderr,
-                        stdout
-                    });
-                }
-                catch (err) {
-                    Logger.debug('No existing repository found, cloning...');
-                    await fs.rm(this.tempDir, { recursive: true, force: true });
-                    const { stdout, stderr } = await execAsync(`git clone ${GITHUB_REPO.url} ${this.tempDir}`);
-                    Logger.debug({
-                        action: 'git_clone',
-                        stderr,
-                        stdout,
-                        url: GITHUB_REPO.url
-                    });
-                }
+                // Clean up temp directory
+                await fs.rm(this.tempDir, { recursive: true, force: true });
+                // Download latest release
+                Logger.debug('Downloading latest release...');
+                const { downloadGithubRelease } = await import('../utils/githubUtils.js');
+                const { version, downloadPath } = await downloadGithubRelease(GITHUB_REPO.repoName, 'latest', GITHUB_REPO.feedAssetsName, undefined, true, this.tempDir);
+                Logger.debug({
+                    action: 'download_release',
+                    downloadPath,
+                    version,
+                    repoName: GITHUB_REPO.repoName,
+                });
                 Logger.debug('Updating local feeds...');
                 await fs.rm(LOCAL_FEEDS_DIR, { recursive: true, force: true });
-                const sourceFeedsDir = path.join(this.tempDir, GITHUB_REPO.feedsPath);
+                const sourceFeedsDir = downloadPath;
                 try {
-                    await fs.access(sourceFeedsDir);
+                    await fs.access(downloadPath);
                 }
                 catch (err) {
-                    throw new Error(`Could not find feeds directory in cloned repository: ${sourceFeedsDir}`);
+                    throw new Error(`Could not find feeds directory in downloaded path: ${sourceFeedsDir}`);
                 }
                 await fs.cp(sourceFeedsDir, LOCAL_FEEDS_DIR, { recursive: true, force: true });
                 Logger.log('Successfully updated local feeds');

package/dist/core/InstallationService.d.ts

@@ -30,4 +30,21 @@ export declare class InstallationService {
      * @returns A failure result if requirements check fails, null if requirements are satisfied
      */
     private checkAndInstallRequirements;
+    /**
+     * Installs requirements in background without blocking the main thread
+     * Requirements with the same order are installed in parallel
+     */
+    private installRequirementsInBackground;
+    /**
+     * Helper to update requirement status for failure case
+     */
+    private updateRequirementFailureStatus;
+    /**
+     * Helper to update requirement status for in-progress case
+     */
+    private updateRequirementProgressStatus;
+    /**
+     * Helper to update requirement status for completion case
+     */
+    private updateRequirementCompletionStatus;
 }

package/dist/core/InstallationService.js

@@ -34,7 +34,7 @@ export class InstallationService {
         // Fire off requirement updates in the background without awaiting completion
         if (options.requirements && options.requirements.length > 0) {
             // Start the process but don't await it - it will run in the background
-            this.processRequirementUpdates(categoryName, serverName, options.requirements)
+            this.processRequirementUpdates(categoryName, serverName, options)
                 .catch(error => {
                 console.error(`Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`);
             });
@@ -70,7 +70,7 @@ export class InstallationService {
      * @param serverName The server name
      * @param requirements The requirements to update
      */
-    async processRequirementUpdates(categoryName, serverName, requirements) {
+    async processRequirementUpdates(categoryName, serverName, options) {
         // Use UpdateCheckTracker to prevent concurrent updates
         const updateCheckTracker = await import('../utils/UpdateCheckTracker.js').then(m => m.updateCheckTracker);
         const operationKey = `requirement-updates-${categoryName}-${serverName}`;
@@ -90,7 +90,7 @@ export class InstallationService {
             // Import the RequirementService
             const { requirementService } = await import('./RequirementService.js');
             // Create an array of promises to update all requirements in parallel
-            const updatePromises = requirements.map(async (reqToUpdate) => {
+            const updatePromises = options.requirements?.map(async (reqToUpdate) => {
                 try {
                     // Find the full requirement config
                     const reqConfig = feedConfig.requirements?.find((r) => r.name === reqToUpdate.name);
@@ -123,8 +123,15 @@ export class InstallationService {
                         ...reqConfig,
                         version: reqToUpdate.version
                     };
-                    // Update the requirement
-                    const updatedStatus = await requirementService.updateRequirement(updatedReqConfig, reqToUpdate.version);
+                    // For pip requirements, check if we have a stored pythonEnv
+                    if (updatedReqConfig.type === 'pip' && currentStatus.pythonEnv && !options?.settings?.pythonEnv) {
+                        options = {
+                            ...options,
+                            settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
+                        };
+                    }
+                    // Update the requirement with options for pip environment
+                    const updatedStatus = await requirementService.updateRequirement(updatedReqConfig, reqToUpdate.version, options);
                     // Update requirement status
                     await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
                         ...updatedStatus,
@@ -162,8 +169,10 @@ export class InstallationService {
                     });
                 }
             });
-            // Wait for all updates to complete in parallel
-            await Promise.all(updatePromises);
+            // Wait for all updates to complete in parallel if there are any
+            if (updatePromises) {
+                await Promise.all(updatePromises);
+            }
         }
         finally {
             // Always release the lock when done, even if there was an error
@@ -226,62 +235,119 @@ export class InstallationService {
             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, {
+        // Start requirements installation in background
+        this.installRequirementsInBackground(categoryName, sortedRequirements, options)
+            .catch(error => {
+            Logger.error(`Error in background requirement installations: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        // Return immediately while installation continues in background
+        return null;
+    }
+    /**
+     * Installs requirements in background without blocking the main thread
+     * Requirements with the same order are installed in parallel
+     */
+    async installRequirementsInBackground(categoryName, sortedRequirements, options) {
+        const configProvider = ConfigurationProvider.getInstance();
+        const requirementGroups = sortedRequirements.reduce((groups, req) => {
+            const order = req.order ?? Infinity;
+            if (!groups[order]) {
+                groups[order] = [];
+            }
+            groups[order].push(req);
+            return groups;
+        }, {});
+        // Process each group in sequence, but requirements within group in parallel
+        const orderKeys = Object.keys(requirementGroups).map(Number).sort((a, b) => a - b);
+        for (const order of orderKeys) {
+            const group = requirementGroups[order];
+            await Promise.all(group.map(async (requirement) => {
+                try {
+                    const feeds = await configProvider.getFeedConfiguration(categoryName);
+                    const requirementConfig = feeds?.requirements?.find((r) => r.name === 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
-                        }
+                        version: requirement.version,
+                        type: 'npm'
                     };
-                    await configProvider.updateRequirementStatus(categoryName, requirement.name, status);
-                });
-            });
-        }, Promise.resolve());
-        return null;
+                    // For pip requirements, check if we need to use stored pythonEnv
+                    const currentStatus = await configProvider.getRequirementStatus(categoryName, requirement.name);
+                    if (requirementConfig.type === 'pip' && currentStatus?.pythonEnv && !options?.settings?.pythonEnv) {
+                        options = {
+                            ...options,
+                            settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
+                        };
+                    }
+                    const installer = this.installerFactory.getInstaller(requirementConfig);
+                    if (!installer) {
+                        await this.updateRequirementFailureStatus(categoryName, requirement.name, requirementConfig.type, `No installer found for requirement type: ${requirementConfig.type}`);
+                        return;
+                    }
+                    const operationId = this.generateOperationId();
+                    await this.updateRequirementProgressStatus(categoryName, requirement.name, requirementConfig.type, operationId);
+                    const installStatus = await installer.install(requirementConfig, options);
+                    await this.updateRequirementCompletionStatus(categoryName, requirement.name, installStatus, operationId);
+                }
+                catch (error) {
+                    await this.updateRequirementFailureStatus(categoryName, requirement.name, 'unknown', error instanceof Error ? error.message : String(error));
+                }
+            }));
+        }
+    }
+    /**
+     * Helper to update requirement status for failure case
+     */
+    async updateRequirementFailureStatus(categoryName, requirementName, requirementType, errorMessage) {
+        const configProvider = ConfigurationProvider.getInstance();
+        await configProvider.updateRequirementStatus(categoryName, requirementName, {
+            name: requirementName,
+            type: requirementType,
+            installed: false,
+            error: errorMessage,
+            operationStatus: {
+                status: 'failed',
+                type: 'install',
+                target: 'requirement',
+                message: `Error installing requirement: ${errorMessage}`,
+                operationId: this.generateOperationId()
+            }
+        });
+    }
+    /**
+     * Helper to update requirement status for in-progress case
+     */
+    async updateRequirementProgressStatus(categoryName, requirementName, requirementType, operationId) {
+        const configProvider = ConfigurationProvider.getInstance();
+        await configProvider.updateRequirementStatus(categoryName, requirementName, {
+            name: requirementName,
+            type: requirementType,
+            installed: false,
+            inProgress: true,
+            operationStatus: {
+                status: 'in-progress',
+                type: 'install',
+                target: 'requirement',
+                message: `Installing requirement: ${requirementName}`,
+                operationId
+            }
+        });
+    }
+    /**
+     * Helper to update requirement status for completion case
+     */
+    async updateRequirementCompletionStatus(categoryName, requirementName, installStatus, operationId) {
+        const configProvider = ConfigurationProvider.getInstance();
+        await configProvider.updateRequirementStatus(categoryName, requirementName, {
+            ...installStatus,
+            operationStatus: {
+                status: installStatus.installed ? 'completed' : 'failed',
+                type: 'install',
+                target: 'requirement',
+                message: installStatus.installed
+                    ? `Requirement ${requirementName} installed successfully`
+                    : `Failed to install ${requirementName}`,
+                operationId
+            }
+        });
     }
 }
 // Export a singleton instance (optional)

package/dist/core/MCPManager.d.ts

@@ -8,6 +8,7 @@ export declare class MCPManager extends EventEmitter {
     initialize(feedFile?: string): Promise<void>;
     listServerCategories(options?: ServerCategoryListOptions): Promise<MCPServerCategory[]>;
     getFeedConfiguration(categoryName: string): Promise<import("./types.js").FeedConfiguration | undefined>;
+    getServerMcpConfig(categoryName: string, serverName: string): Promise<import("./types.js").McpConfig | undefined>;
     installServer(categoryName: string, serverName: string, requestOptions?: ServerInstallOptions): Promise<ServerOperationResult>;
     uninstallServer(categoryName: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
     updateRequirement(categoryName: string, serverName: string, requirementName: string, updateVersion: string): Promise<ServerOperationResult>;

package/dist/core/MCPManager.js

@@ -32,6 +32,9 @@ export class MCPManager extends EventEmitter {
     async getFeedConfiguration(categoryName) {
         return this.configProvider.getFeedConfiguration(categoryName);
     }
+    async getServerMcpConfig(categoryName, serverName) {
+        return this.configProvider.getServerMcpConfig(categoryName, serverName);
+    }
     async installServer(categoryName, serverName, requestOptions = {}) {
         try {
             const server = await this.configProvider.getServerCategory(categoryName);

package/dist/core/RequirementService.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus } from './types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from './types.js';
 /**
  * Service responsible for managing requirements installation and status
  */
@@ -16,13 +16,13 @@ export declare class RequirementService {
      * @param requirement The requirement to install
      * @returns The installation status
      */
-    installRequirement(requirement: RequirementConfig): Promise<RequirementStatus>;
+    installRequirement(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Check the installation status of a requirement
      * @param requirement The requirement to check
      * @returns The installation status
      */
-    checkRequirementStatus(requirement: RequirementConfig): Promise<RequirementStatus>;
+    checkRequirementStatus(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Check if updates are available for a requirement
      * @param requirement The requirement to check for updates
@@ -35,7 +35,7 @@ export declare class RequirementService {
      * @param updateVersion The version to update to
      * @returns The updated requirement status
      */
-    updateRequirement(requirement: RequirementConfig, updateVersion: string): Promise<RequirementStatus>;
+    updateRequirement(requirement: RequirementConfig, updateVersion: string, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Install multiple requirements
      * @param requirements The requirements to install

package/dist/core/RequirementService.js

@@ -23,22 +23,22 @@ export class RequirementService {
      * @param requirement The requirement to install
      * @returns The installation status
      */
-    async installRequirement(requirement) {
+    async installRequirement(requirement, options) {
         // Validate requirement
         this.validateRequirement(requirement);
         // Install the requirement
-        return await this.installerFactory.install(requirement);
+        return await this.installerFactory.install(requirement, options);
     }
     /**
      * Check the installation status of a requirement
      * @param requirement The requirement to check
      * @returns The installation status
      */
-    async checkRequirementStatus(requirement) {
+    async checkRequirementStatus(requirement, options) {
         // Validate requirement
         this.validateRequirement(requirement);
         // Check the installation status
-        return await this.installerFactory.checkInstallation(requirement);
+        return await this.installerFactory.checkInstallation(requirement, options);
     }
     /**
      * Check if updates are available for a requirement
@@ -54,7 +54,11 @@ export class RequirementService {
         if (!installer || !installer.supportCheckUpdates()) {
             return currentStatus;
         }
-        const status = await this.checkRequirementStatus(requirement);
+        // Pass pythonEnv from currentStatus if it exists for pip packages
+        const options = requirement.type === 'pip' && currentStatus.pythonEnv
+            ? { settings: { pythonEnv: currentStatus.pythonEnv } }
+            : undefined;
+        const status = await this.checkRequirementStatus(requirement, options);
         return await installer.checkForUpdates(requirement, status);
     }
     /**
@@ -63,7 +67,7 @@ export class RequirementService {
      * @param updateVersion The version to update to
      * @returns The updated requirement status
      */
-    async updateRequirement(requirement, updateVersion) {
+    async updateRequirement(requirement, updateVersion, options) {
         // Validate requirement
         this.validateRequirement(requirement);
         // Create an updated requirement with the new version
@@ -72,7 +76,7 @@ export class RequirementService {
             version: updateVersion
         };
         // Install the updated version
-        return await this.installRequirement(updatedRequirement);
+        return await this.installerFactory.install(updatedRequirement, options);
     }
     /**
      * Install multiple requirements

package/dist/core/ServerSchemaProvider.d.ts

@@ -11,7 +11,7 @@ export declare class ServerSchemaProvider {
     initialize(): Promise<void>;
     private loadSchema;
     private loadAllSchemas;
-    getSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined>;
+    getSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined>;
     reloadSchemas(): Promise<void>;
 }
 export declare function getServerSchemaProvider(): Promise<ServerSchemaProvider>;

package/dist/core/ServerSchemaProvider.js

@@ -42,9 +42,9 @@ export class ServerSchemaProvider {
             }
         });
     }
-    async loadSchema(categoryName, serverName) {
+    async loadSchema(categoryName, schemaFileName) {
         try {
-            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, `${serverName}.json`);
+            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, schemaFileName);
             const content = await fs.readFile(schemaPath, 'utf8');
             const schema = JSON.parse(content);
             return {
@@ -53,10 +53,10 @@ export class ServerSchemaProvider {
         }
         catch (error) {
             if (error.code === 'ENOENT') {
-                Logger.debug(`No schema file found for server ${serverName} in category ${categoryName}`);
+                Logger.debug(`No schema file found for ${schemaFileName} in category ${categoryName}`);
                 return undefined;
             }
-            Logger.error(`Error loading schema for server ${serverName} in category ${categoryName}:`, error);
+            Logger.error(`Error loading schema ${schemaFileName} in category ${categoryName}:`, error);
             throw error;
         }
     }
@@ -71,15 +71,15 @@ export class ServerSchemaProvider {
                 const serverSchemas = new Map();
                 for (const file of serverFiles) {
                     if (file.endsWith('.json')) {
-                        const serverName = path.basename(file, '.json');
                         try {
-                            const schema = await this.loadSchema(categoryDir.name, serverName);
+                            const schema = await this.loadSchema(categoryDir.name, file);
                             if (schema) {
-                                serverSchemas.set(serverName, schema);
+                                // Store with the complete file name for direct lookup
+                                serverSchemas.set(file, schema);
                             }
                         }
                         catch (error) {
-                            Logger.error(`Error loading schema for server ${serverName} in category ${categoryDir.name}:`, error);
+                            Logger.error(`Error loading schema for file ${file} in category ${categoryDir.name}:`, error);
                         }
                     }
                 }
@@ -89,13 +89,18 @@ export class ServerSchemaProvider {
             }
         }
     }
-    async getSchema(categoryName, serverName) {
+    async getSchema(categoryName, schemaFileName) {
         return await this.withLock(async () => {
             const categorySchemas = this.schemaMap.get(categoryName);
             if (!categorySchemas) {
+                Logger.debug(`No schemas found for category ${categoryName}`);
                 return undefined;
             }
-            return categorySchemas.get(serverName);
+            const schema = categorySchemas.get(schemaFileName);
+            if (!schema) {
+                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
+            }
+            return schema;
         });
     }
     async reloadSchemas() {

package/dist/core/constants.d.ts

@@ -6,7 +6,9 @@
  */
 export declare const GITHUB_REPO: {
     url: string;
+    repoName: string;
     feedsPath: string;
+    feedAssetsName: string;
 };
 /**
  * Local settings directory path based on OS
@@ -16,6 +18,7 @@ export declare const SETTINGS_DIR: string;
  * Local feeds directory path
  */
 export declare const LOCAL_FEEDS_DIR: string;
+export declare const LOCAL_FEEDS_SCHEMA_DIR: string;
 /**
  * Supported client configurations.
  * Key: Client name (e.g., 'vscode')

package/dist/core/constants.js

@@ -8,7 +8,9 @@ import path from 'path';
  */
 export const GITHUB_REPO = {
     url: 'https://github.com/ai-microsoft/imcp-feed.git',
-    feedsPath: 'feeds'
+    repoName: 'ai-microsoft/imcp-feed',
+    feedsPath: 'feeds',
+    feedAssetsName: 'imcp-feeds-${latest}.zip',
 };
 /**
  * Local settings directory path based on OS
@@ -25,6 +27,7 @@ export const SETTINGS_DIR = (() => {
  * Local feeds directory path
  */
 export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
+export const LOCAL_FEEDS_SCHEMA_DIR = path.join(LOCAL_FEEDS_DIR, 'schemas');
 const CODE_STRORAGE_DIR = (() => {
     switch (process.platform) {
         case 'win32':