imcp 0.0.12 → 0.0.14

package/src/core/ConfigurationProvider.ts

@@ -14,7 +14,8 @@ import {
     RequirementStatus,
     MCPServerStatus,
     OperationStatus,
-    ClientSettings
+    ClientSettings,
+    McpConfig
 } from './types.js';
 import { ConfigurationLoader } from './ConfigurationLoader.js';
 
@@ -115,6 +116,12 @@ export class ConfigurationProvider {
         });
     }
 
+    async getServerMcpConfig(categoryName: string, serverName: string): Promise<McpConfig | undefined> {
+        return await this.withLock(async () => {
+            return this.configuration.feeds[categoryName]?.mcpServers.find(s => s.name === serverName);
+        });
+    }
+
     async getInstallationStatus(categoryName: string): Promise<InstallationStatus | undefined> {
         return await this.withLock(async () => {
             // Inline getServerCategory logic
@@ -300,35 +307,36 @@ 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 });
@@ -362,7 +370,7 @@ export class ConfigurationProvider {
         return await this.withLock(async () => {
             // Load utils in async context to avoid circular dependencies
             const { readJsonFile, writeJsonFile } = await import('../utils/clientUtils.js');
-            
+
             // Filter clients if target is specified
             const clientEntries = Object.entries(SUPPORTED_CLIENTS as Record<string, ClientSettings>);
             const targetClients = target
@@ -373,11 +381,11 @@ export class ConfigurationProvider {
                 const settingPath = process.env.CODE_INSIDERS
                     ? clientSettings.codeInsiderSettingPath
                     : clientSettings.codeSettingPath;
-                
+
                 try {
                     const content = await readJsonFile(settingPath, true);
                     let modified = false;
-                    
+
                     // Handle GitHub Copilot's different structure
                     if (clientName === 'GithubCopilot' && content.mcp?.servers?.[serverName]) {
                         delete content.mcp.servers[serverName];
@@ -386,7 +394,7 @@ export class ConfigurationProvider {
                         delete content.mcpServers[serverName];
                         modified = true;
                     }
-                    
+
                     // Only write if we actually modified the content
                     if (modified) {
                         await writeJsonFile(settingPath, content);
@@ -396,7 +404,7 @@ export class ConfigurationProvider {
                     Logger.error(`Failed to remove server ${serverName} from client ${clientName} settings:`, error);
                 }
             }
-            
+
             // Also update our in-memory configuration
             if (this.configuration.clientMCPSettings) {
                 if (target) {

package/src/core/InstallationService.ts

@@ -50,7 +50,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)}`);
         });
@@ -91,7 +91,7 @@ export class InstallationService {
    * @param serverName The server name
    * @param requirements The requirements to update
    */
-  private async processRequirementUpdates(categoryName: string, serverName: string, requirements: { name: string, version: string }[]): Promise<void> {
+  private async processRequirementUpdates(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<void> {
     // Use UpdateCheckTracker to prevent concurrent updates
     const updateCheckTracker = await import('../utils/UpdateCheckTracker.js').then(m => m.updateCheckTracker);
     const operationKey = `requirement-updates-${categoryName}-${serverName}`;
@@ -116,7 +116,7 @@ export class InstallationService {
       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: RequirementConfig) => r.name === reqToUpdate.name);
@@ -155,8 +155,16 @@ export class InstallationService {
             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, {
@@ -197,8 +205,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
       await updateCheckTracker.endOperation(operationKey);
@@ -270,67 +280,171 @@ export class InstallationService {
       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'
-        };
+    // 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)}`);
+      });
 
-        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;
-        }
+    // Return immediately while installation continues in background
+    return null;
+  }
 
-        const operationStatus: OperationStatus = {
-          status: 'pending',
-          type: 'install',
-          target: 'requirement',
-          message: `Installing requirement: ${requirement.name}`,
-          operationId: this.generateOperationId()
-        };
+  /**
+   * Installs requirements in background without blocking the main thread
+   * Requirements with the same order are installed in parallel
+   */
+  private async installRequirementsInBackground(
+    categoryName: string,
+    sortedRequirements: Array<{ name: string; version: string; order?: number }>,
+    options: ServerInstallOptions
+  ): Promise<void> {
+    const configProvider = ConfigurationProvider.getInstance();
 
-        await configProvider.updateRequirementStatus(categoryName, requirement.name, {
-          name: requirement.name,
-          type: requirementConfig.type,
-          installed: false,
-          inProgress: true,
-          operationStatus
-        });
+    // Group requirements by order
+    type RequirementType = { name: string; version: string; order?: number };
+    const requirementGroups = sortedRequirements.reduce<Record<number, RequirementType[]>>((groups, req) => {
+      const order = req.order ?? Infinity;
+      if (!groups[order]) {
+        groups[order] = [];
+      }
+      groups[order].push(req);
+      return groups;
+    }, {});
 
-        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
-            }
+    // 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: RequirementConfig) => r.name === requirement.name) || {
+            name: requirement.name,
+            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
+   */
+  private async updateRequirementFailureStatus(
+    categoryName: string,
+    requirementName: string,
+    requirementType: string,
+    errorMessage: string
+  ): Promise<void> {
+    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
+   */
+  private async updateRequirementProgressStatus(
+    categoryName: string,
+    requirementName: string,
+    requirementType: string,
+    operationId: string
+  ): Promise<void> {
+    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
+   */
+  private async updateRequirementCompletionStatus(
+    categoryName: string,
+    requirementName: string,
+    installStatus: RequirementStatus,
+    operationId: string
+  ): Promise<void> {
+    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
+      }
+    });
   }
 }
 

package/src/core/MCPManager.ts

@@ -48,6 +48,10 @@ export class MCPManager extends EventEmitter {
     return this.configProvider.getFeedConfiguration(categoryName);
   }
 
+  async getServerMcpConfig(categoryName: string, serverName: string) {
+    return this.configProvider.getServerMcpConfig(categoryName, serverName);
+  }
+
   async installServer(
     categoryName: string,
     serverName: string,

package/src/core/RequirementService.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus } from './types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from './types.js';
 import { createInstallerFactory } from './installers/index.js';
 import { exec } from 'child_process';
 import util from 'util';
@@ -28,12 +28,12 @@ export class RequirementService {
      * @param requirement The requirement to install
      * @returns The installation status
      */
-    public async installRequirement(requirement: RequirementConfig): Promise<RequirementStatus> {
+    public async installRequirement(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
         // Validate requirement
         this.validateRequirement(requirement);
 
         // Install the requirement
-        return await this.installerFactory.install(requirement);
+        return await this.installerFactory.install(requirement, options);
     }
 
     /**
@@ -41,12 +41,12 @@ export class RequirementService {
      * @param requirement The requirement to check
      * @returns The installation status
      */
-    public async checkRequirementStatus(requirement: RequirementConfig): Promise<RequirementStatus> {
+    public async checkRequirementStatus(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
         // Validate requirement
         this.validateRequirement(requirement);
 
         // Check the installation status
-        return await this.installerFactory.checkInstallation(requirement);
+        return await this.installerFactory.checkInstallation(requirement, options);
     }
 
     /**
@@ -66,7 +66,11 @@ export class RequirementService {
             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 as any).checkForUpdates(requirement, status);
     }
 
@@ -76,7 +80,7 @@ export class RequirementService {
      * @param updateVersion The version to update to
      * @returns The updated requirement status
      */
-    public async updateRequirement(requirement: RequirementConfig, updateVersion: string): Promise<RequirementStatus> {
+    public async updateRequirement(requirement: RequirementConfig, updateVersion: string, options?: ServerInstallOptions): Promise<RequirementStatus> {
         // Validate requirement
         this.validateRequirement(requirement);
 
@@ -87,7 +91,7 @@ export class RequirementService {
         };
 
         // Install the updated version
-        return await this.installRequirement(updatedRequirement);
+        return await this.installerFactory.install(updatedRequirement, options);
     }
 
     /**

package/src/core/ServerSchemaLoader.ts

@@ -0,0 +1,48 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
+import { Logger } from '../utils/logger.js';
+import { ServerSchema } from './ServerSchemaProvider.js';
+
+export class ServerSchemaLoader {
+    /**
+     * Load schema for a specific server in a category
+     */
+    static async loadSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined> {
+        try {
+            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, `${serverName}.json`);
+            const content = await fs.readFile(schemaPath, 'utf8');
+            const schema = JSON.parse(content);
+
+            // Validate schema structure
+            if (!schema.version || !schema.schema) {
+                Logger.debug(`Invalid schema format for server ${serverName} in category ${categoryName}`);
+                return undefined;
+            }
+
+            return {
+                schema: schema
+            };
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+                Logger.debug(`No schema file found for server ${serverName} in category ${categoryName}`);
+                return undefined;
+            }
+            Logger.error(`Error loading schema for server ${serverName} in category ${categoryName}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Validate schema content against expected format
+     */
+    static validateSchema(schema: any): boolean {
+        return (
+            typeof schema === 'object' &&
+            schema !== null &&
+            typeof schema.version === 'string' &&
+            typeof schema.schema === 'object' &&
+            schema.schema !== null
+        );
+    }
+}

package/src/core/ServerSchemaProvider.ts

@@ -0,0 +1,137 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
+import { Logger } from '../utils/logger.js';
+
+export interface ServerSchema {
+    schema: Record<string, any>;
+}
+
+export class ServerSchemaProvider {
+    private static instance: ServerSchemaProvider;
+    private schemaMap: Map<string, Map<string, ServerSchema>>;
+    private schemaLock: Promise<void> = Promise.resolve();
+
+    private constructor() {
+        this.schemaMap = new Map();
+    }
+
+    public static async getInstance(): Promise<ServerSchemaProvider> {
+        if (!ServerSchemaProvider.instance) {
+            ServerSchemaProvider.instance = new ServerSchemaProvider();
+            await ServerSchemaProvider.instance.initialize();
+        }
+        return ServerSchemaProvider.instance;
+    }
+
+    private async withLock<T>(operation: () => Promise<T>): Promise<T> {
+        const current = this.schemaLock;
+        let resolve: () => void;
+        this.schemaLock = new Promise<void>(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        } finally {
+            resolve!();
+        }
+    }
+
+    async initialize(): Promise<void> {
+        await this.withLock(async () => {
+            try {
+                // Create feeds directory if it doesn't exist
+                await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR, { recursive: true });
+
+                // Load all schemas from the feeds directory
+                await this.loadAllSchemas();
+            } catch (error) {
+                Logger.error('Error during schema initialization:', error);
+                throw error;
+            }
+        });
+    }
+
+    private async loadSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined> {
+        try {
+            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, schemaFileName);
+            const content = await fs.readFile(schemaPath, 'utf8');
+            const schema = JSON.parse(content);
+
+            return {
+                schema: schema
+            };
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+                Logger.debug(`No schema file found for ${schemaFileName} in category ${categoryName}`);
+                return undefined;
+            }
+            Logger.error(`Error loading schema ${schemaFileName} in category ${categoryName}:`, error);
+            throw error;
+        }
+    }
+
+    private async loadAllSchemas(): Promise<void> {
+        this.schemaMap.clear();
+
+        // Read server category directories
+        const categoryDirs = await fs.readdir(LOCAL_FEEDS_SCHEMA_DIR, { withFileTypes: true });
+
+        for (const categoryDir of categoryDirs) {
+            if (categoryDir.isDirectory()) {
+                const categoryPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryDir.name);
+                const serverFiles = await fs.readdir(categoryPath);
+
+                const serverSchemas = new Map<string, ServerSchema>();
+
+                for (const file of serverFiles) {
+                    if (file.endsWith('.json')) {
+                        try {
+                            const schema = await this.loadSchema(categoryDir.name, file);
+                            if (schema) {
+                                // Store with the complete file name for direct lookup
+                                serverSchemas.set(file, schema);
+                            }
+                        } catch (error) {
+                            Logger.error(`Error loading schema for file ${file} in category ${categoryDir.name}:`, error);
+                        }
+                    }
+                }
+
+                if (serverSchemas.size > 0) {
+                    this.schemaMap.set(categoryDir.name, serverSchemas);
+                }
+            }
+        }
+    }
+
+    async getSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined> {
+        return await this.withLock(async () => {
+            const categorySchemas = this.schemaMap.get(categoryName);
+            if (!categorySchemas) {
+                Logger.debug(`No schemas found for category ${categoryName}`);
+                return undefined;
+            }
+            const schema = categorySchemas.get(schemaFileName);
+            if (!schema) {
+                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
+            }
+            return schema;
+        });
+    }
+
+    async reloadSchemas(): Promise<void> {
+        return await this.withLock(async () => {
+            await this.loadAllSchemas();
+        });
+    }
+}
+
+// Export a lazy initialized singleton instance getter
+let initPromise: Promise<ServerSchemaProvider> | null = null;
+
+export function getServerSchemaProvider(): Promise<ServerSchemaProvider> {
+    if (!initPromise) {
+        initPromise = ServerSchemaProvider.getInstance();
+    }
+    return initPromise;
+}