imcp 0.0.11 → 0.0.13

package/dist/cli/commands/uninstall.js

@@ -3,19 +3,27 @@ import { serverService } from '../../services/ServerService.js';
 export function createUninstallCommand() {
     return new Command('uninstall')
         .description('Uninstall specific MCP servers')
-        .requiredOption('--category <category>', '--names <names>', 'Server names (semicolon separated)')
-        .option('--remove-data', 'Remove all associated data', false)
+        .requiredOption('--category <category>', 'Server category')
+        .requiredOption('--names <names>', 'Server names (semicolon separated)')
+        .requiredOption('--targets <targets>', 'Target clients to uninstall from (semicolon separated)')
+        .option('--remove-data', 'Remove all associated data', true // Change default to true to ensure cleanup happens
+    )
         .action(async (options) => {
         try {
             const serverNames = options.names.split(';').map((name) => name.trim());
-            if (!serverService.validateServerName(options.category, serverNames)) {
+            const validNames = await serverService.validateServerName(options.category, serverNames);
+            if (!validNames) {
                 console.error('Invalid server names provided');
                 process.exit(1);
             }
             console.log(`Uninstalling servers: ${serverNames.join(', ')}`);
-            const results = await Promise.all(serverNames.map((serverName) => serverService.uninstallMcpServer(options.category, serverName, {
-                removeData: options.removeData,
-            })));
+            const results = await Promise.all(serverNames.map((serverName) => {
+                const targets = options.targets ? options.targets.split(';').map((t) => t.trim()) : [];
+                return serverService.uninstallMcpServer(options.category, serverName, {
+                    removeData: options.removeData,
+                    targets: targets
+                });
+            }));
             const { success, messages } = serverService.formatOperationResults(results);
             messages.forEach(message => {
                 if (success) {

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>;
@@ -28,5 +29,6 @@ export declare class ConfigurationProvider {
     private loadFeedsIntoConfiguration;
     private loadClientMCPSettings;
     reloadClientMCPSettings(): Promise<void>;
+    removeServerFromClientMCPSettings(serverName: string, target?: string): Promise<void>;
 }
 export declare const configProvider: ConfigurationProvider;

package/dist/core/ConfigurationProvider.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
-import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR } from './constants.js';
+import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR, SUPPORTED_CLIENTS } from './constants.js';
 import { Logger } from '../utils/logger.js';
 import { checkGithubAuth } from '../utils/githubAuth.js';
 import { ConfigurationLoader } from './ConfigurationLoader.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');
@@ -294,6 +290,70 @@ export class ConfigurationProvider {
             await this.loadClientMCPSettings();
         });
     }
+    async removeServerFromClientMCPSettings(serverName, target) {
+        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);
+            const targetClients = target
+                ? clientEntries.filter(([clientName]) => clientName === target)
+                : clientEntries;
+            for (const [clientName, clientSettings] of targetClients) {
+                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];
+                        modified = true;
+                    }
+                    else if (content.mcpServers?.[serverName]) {
+                        delete content.mcpServers[serverName];
+                        modified = true;
+                    }
+                    // Only write if we actually modified the content
+                    if (modified) {
+                        await writeJsonFile(settingPath, content);
+                        Logger.debug(`Removed server ${serverName} from client ${clientName} settings`);
+                    }
+                }
+                catch (error) {
+                    Logger.error(`Failed to remove server ${serverName} from client ${clientName} settings:`, error);
+                }
+            }
+            // Also update our in-memory configuration
+            if (this.configuration.clientMCPSettings) {
+                if (target) {
+                    // Only update settings for the target client
+                    const clientSettings = this.configuration.clientMCPSettings[target];
+                    if (clientSettings) {
+                        if (clientSettings.mcpServers?.[serverName]) {
+                            delete clientSettings.mcpServers[serverName];
+                        }
+                        if (clientSettings.servers?.[serverName]) { // For GitHub Copilot
+                            delete clientSettings.servers[serverName];
+                        }
+                    }
+                }
+                else {
+                    // Update all clients if no target specified
+                    for (const clientSettings of Object.values(this.configuration.clientMCPSettings)) {
+                        if (clientSettings.mcpServers?.[serverName]) {
+                            delete clientSettings.mcpServers[serverName];
+                        }
+                        if (clientSettings.servers?.[serverName]) { // For GitHub Copilot
+                            delete clientSettings.servers[serverName];
+                        }
+                    }
+                }
+                await this.saveConfiguration();
+            }
+        });
+    }
 }
 // Export a singleton instance
 export const configProvider = ConfigurationProvider.getInstance();

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

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'events';
 import { ConfigurationProvider } from './ConfigurationProvider.js';
 import { InstallationService } from './InstallationService.js';
-import { MCPEvent, } from './types.js';
+import { MCPEvent } from './types.js';
 export class MCPManager extends EventEmitter {
     installationService;
     configProvider;
@@ -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);
@@ -66,12 +69,34 @@ export class MCPManager extends EventEmitter {
                     message: `Server category ${categoryName} is not onboarded`,
                 };
             }
-            // Clear installation status
-            await this.configProvider.updateInstallationStatus(categoryName, {}, {});
-            this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName });
+            const { targets = [], removeData = false } = options;
+            // Clear installation status for specified targets
+            const currentStatus = serverCategory.installationStatus || {
+                requirementsStatus: {},
+                serversStatus: {},
+                lastUpdated: new Date().toISOString()
+            };
+            const serversStatus = currentStatus.serversStatus || {};
+            const serverStatus = serversStatus[serverName] || { installedStatus: {}, name: serverName };
+            // Only reset installedStatus for specified targets
+            for (const target of targets) {
+                if (serverStatus.installedStatus) {
+                    delete serverStatus.installedStatus[target];
+                }
+            }
+            if (removeData) {
+                for (const target of targets) {
+                    await this.configProvider.removeServerFromClientMCPSettings(serverName, target);
+                }
+            }
+            // Update server status
+            serversStatus[serverName] = serverStatus;
+            // Update status keeping requirements
+            await this.configProvider.updateInstallationStatus(categoryName, currentStatus.requirementsStatus || {}, serversStatus);
+            this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName, targets });
             return {
                 success: true,
-                message: `Successfully uninstalled ${serverName}`,
+                message: `Successfully uninstalled ${serverName} from ${targets.join(', ')}`,
             };
         }
         catch (error) {

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/ServerSchemaLoader.js

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { LOCAL_FEEDS_DIR } from './constants.js';
+import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
 import { Logger } from '../utils/logger.js';
 export class ServerSchemaLoader {
     /**
@@ -8,7 +8,7 @@ export class ServerSchemaLoader {
      */
     static async loadSchema(categoryName, serverName) {
         try {
-            const schemaPath = path.join(LOCAL_FEEDS_DIR, categoryName, `${serverName}.json`);
+            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

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