imcp 0.0.10 → 0.0.12

package/README.md

@@ -40,11 +40,15 @@ imcp serve [options]
 
 Options:
 - `-p, --port <port>`: Port to run the server on (default: 3000)
+- `-f, --feed-file <filepath>`: Path to a custom feed configuration file
 
 Example:
 ```bash
 # Start the web interface on port 8080
 imcp serve --port 8080
+
+# Start with a custom feed configuration file
+imcp serve --feed-file ./custom-feed.json
 ```
 
 ## License

package/dist/cli/commands/serve.js

@@ -5,12 +5,13 @@ export function createServeCommand() {
     return new Command('serve')
         .description('Serve local web interface')
         .option('-p, --port <port>', 'Port to run the server on', '3000')
+        .option('-f, --feed-file <filepath>', 'Path to a custom feed configuration file')
         .action(async (options) => {
         try {
             // Sync feeds before start the local UI
             await mcpManager.syncFeeds();
             // Ensure MCP manager is initialized before starting the web server
-            await mcpManager.initialize();
+            await mcpManager.initialize(options.feedFile);
             const port = parseInt(options.port, 10);
             if (isNaN(port) || port < 1 || port > 65535) {
                 throw new Error('Invalid port number');

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/ConfigurationLoader.d.ts

@@ -24,7 +24,7 @@ export declare class ConfigurationLoader {
     /**
      * Loads feed configurations into the MCP configuration
      */
-    static loadFeedsIntoConfiguration(configuration: MCPConfiguration): Promise<MCPConfiguration>;
+    static loadFeedsIntoConfiguration(configuration: MCPConfiguration, feedFile?: string): Promise<MCPConfiguration>;
     /**
      * Loads MCP client settings into the configuration
      */

package/dist/core/ConfigurationLoader.js

@@ -140,23 +140,44 @@ export class ConfigurationLoader {
     /**
      * Loads feed configurations into the MCP configuration
      */
-    static async loadFeedsIntoConfiguration(configuration) {
+    static async loadFeedsIntoConfiguration(configuration, feedFile) {
         try {
             await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+            const feeds = {};
+            // Load provided feed file if specified
+            if (feedFile) {
+                try {
+                    const content = await fs.readFile(feedFile, 'utf8');
+                    const config = JSON.parse(content);
+                    if (config && config.name) {
+                        feeds[config.name] = config;
+                        console.log(`Loaded feed configuration from provided file: ${feedFile}`);
+                    }
+                }
+                catch (error) {
+                    console.log(`Error loading feed configuration from provided file ${feedFile}:`, error);
+                }
+            }
+            // Load feeds from LOCAL_FEEDS_DIR
             const files = await fs.readdir(LOCAL_FEEDS_DIR);
             const jsonFiles = files.filter(file => file.endsWith('.json'));
-            if (jsonFiles.length === 0) {
+            if (jsonFiles.length === 0 && !feedFile) {
                 console.log(`No feed configuration files found in ${LOCAL_FEEDS_DIR}`);
                 return configuration;
             }
-            const feeds = {};
             for (const file of jsonFiles) {
                 try {
                     const filePath = path.join(LOCAL_FEEDS_DIR, file);
                     const content = await fs.readFile(filePath, 'utf8');
                     const config = JSON.parse(content);
                     if (config && config.name) {
-                        feeds[config.name] = config;
+                        // If feed exists from provided file, skip the local one
+                        if (!feeds[config.name]) {
+                            feeds[config.name] = config;
+                        }
+                        else {
+                            console.log(`Skipping local feed ${config.name} as it was provided via --feed-file`);
+                        }
                     }
                 }
                 catch (error) {

package/dist/core/ConfigurationProvider.d.ts

@@ -8,7 +8,7 @@ export declare class ConfigurationProvider {
     private constructor();
     static getInstance(): ConfigurationProvider;
     private withLock;
-    initialize(): Promise<void>;
+    initialize(feedFile?: string): Promise<void>;
     private saveConfiguration;
     getServerCategories(): Promise<MCPServerCategory[]>;
     getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;
@@ -28,5 +28,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';
@@ -43,7 +43,7 @@ export class ConfigurationProvider {
             resolve();
         }
     }
-    async initialize() {
+    async initialize(feedFile) {
         await this.withLock(async () => {
             const configDir = path.dirname(this.configPath);
             await fs.mkdir(configDir, { recursive: true });
@@ -60,7 +60,7 @@ export class ConfigurationProvider {
                     await this.saveConfiguration();
                 }
                 // Always load feeds and client settings, whether file existed or not
-                await this.loadFeedsIntoConfiguration();
+                await this.loadFeedsIntoConfiguration(feedFile);
                 await this.loadClientMCPSettings();
             }
             catch (error) {
@@ -280,8 +280,8 @@ export class ConfigurationProvider {
             }
         });
     }
-    async loadFeedsIntoConfiguration() {
-        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration);
+    async loadFeedsIntoConfiguration(feedFile) {
+        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile);
         await this.saveConfiguration();
     }
     async loadClientMCPSettings() {
@@ -294,6 +294,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/MCPManager.d.ts

@@ -5,7 +5,7 @@ export declare class MCPManager extends EventEmitter {
     private configProvider;
     constructor();
     syncFeeds(): Promise<void>;
-    initialize(): Promise<void>;
+    initialize(feedFile?: string): Promise<void>;
     listServerCategories(options?: ServerCategoryListOptions): Promise<MCPServerCategory[]>;
     getFeedConfiguration(categoryName: string): Promise<import("./types.js").FeedConfiguration | undefined>;
     installServer(categoryName: string, serverName: string, requestOptions?: ServerInstallOptions): Promise<ServerOperationResult>;

package/dist/core/MCPManager.js

@@ -13,9 +13,9 @@ export class MCPManager extends EventEmitter {
     async syncFeeds() {
         await this.configProvider.syncFeeds();
     }
-    async initialize() {
+    async initialize(feedFile) {
         try {
-            await this.configProvider.initialize();
+            await this.configProvider.initialize(feedFile);
         }
         catch (error) {
             console.error("Error during MCPManager initialization:", error);
@@ -66,12 +66,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/ServerSchemaLoader.d.ts

@@ -0,0 +1,11 @@
+import { ServerSchema } from './ServerSchemaProvider.js';
+export declare class ServerSchemaLoader {
+    /**
+     * Load schema for a specific server in a category
+     */
+    static loadSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined>;
+    /**
+     * Validate schema content against expected format
+     */
+    static validateSchema(schema: any): boolean;
+}

package/dist/core/ServerSchemaLoader.js

@@ -0,0 +1,43 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
+import { Logger } from '../utils/logger.js';
+export class ServerSchemaLoader {
+    /**
+     * Load schema for a specific server in a category
+     */
+    static async loadSchema(categoryName, serverName) {
+        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.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) {
+        return (typeof schema === 'object' &&
+            schema !== null &&
+            typeof schema.version === 'string' &&
+            typeof schema.schema === 'object' &&
+            schema.schema !== null);
+    }
+}
+//# sourceMappingURL=ServerSchemaLoader.js.map

package/dist/core/ServerSchemaProvider.d.ts

@@ -0,0 +1,17 @@
+export interface ServerSchema {
+    schema: Record<string, any>;
+}
+export declare class ServerSchemaProvider {
+    private static instance;
+    private schemaMap;
+    private schemaLock;
+    private constructor();
+    static getInstance(): Promise<ServerSchemaProvider>;
+    private withLock;
+    initialize(): Promise<void>;
+    private loadSchema;
+    private loadAllSchemas;
+    getSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined>;
+    reloadSchemas(): Promise<void>;
+}
+export declare function getServerSchemaProvider(): Promise<ServerSchemaProvider>;

package/dist/core/ServerSchemaProvider.js

@@ -0,0 +1,115 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
+import { Logger } from '../utils/logger.js';
+export class ServerSchemaProvider {
+    static instance;
+    schemaMap;
+    schemaLock = Promise.resolve();
+    constructor() {
+        this.schemaMap = new Map();
+    }
+    static async getInstance() {
+        if (!ServerSchemaProvider.instance) {
+            ServerSchemaProvider.instance = new ServerSchemaProvider();
+            await ServerSchemaProvider.instance.initialize();
+        }
+        return ServerSchemaProvider.instance;
+    }
+    async withLock(operation) {
+        const current = this.schemaLock;
+        let resolve;
+        this.schemaLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async initialize() {
+        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;
+            }
+        });
+    }
+    async loadSchema(categoryName, serverName) {
+        try {
+            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, `${serverName}.json`);
+            const content = await fs.readFile(schemaPath, 'utf8');
+            const schema = JSON.parse(content);
+            return {
+                schema: schema
+            };
+        }
+        catch (error) {
+            if (error.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;
+        }
+    }
+    async loadAllSchemas() {
+        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();
+                for (const file of serverFiles) {
+                    if (file.endsWith('.json')) {
+                        const serverName = path.basename(file, '.json');
+                        try {
+                            const schema = await this.loadSchema(categoryDir.name, serverName);
+                            if (schema) {
+                                serverSchemas.set(serverName, schema);
+                            }
+                        }
+                        catch (error) {
+                            Logger.error(`Error loading schema for server ${serverName} in category ${categoryDir.name}:`, error);
+                        }
+                    }
+                }
+                if (serverSchemas.size > 0) {
+                    this.schemaMap.set(categoryDir.name, serverSchemas);
+                }
+            }
+        }
+    }
+    async getSchema(categoryName, serverName) {
+        return await this.withLock(async () => {
+            const categorySchemas = this.schemaMap.get(categoryName);
+            if (!categorySchemas) {
+                return undefined;
+            }
+            return categorySchemas.get(serverName);
+        });
+    }
+    async reloadSchemas() {
+        return await this.withLock(async () => {
+            await this.loadAllSchemas();
+        });
+    }
+}
+// Export a lazy initialized singleton instance getter
+let initPromise = null;
+export function getServerSchemaProvider() {
+    if (!initPromise) {
+        initPromise = ServerSchemaProvider.getInstance();
+    }
+    return initPromise;
+}
+//# sourceMappingURL=ServerSchemaProvider.js.map

package/dist/core/constants.d.ts

@@ -22,7 +22,17 @@ export declare const LOCAL_FEEDS_DIR: string;
  * Value: Client-specific settings or configuration details.
  * TODO: Define actual client settings structure.
  */
-export declare const SUPPORTED_CLIENTS: Record<string, any>;
+export declare const SUPPORTED_CLIENTS: Record<string, {
+    extension: {
+        extensionId: string;
+        leastVersion?: string;
+        repository?: string;
+        assetName?: string;
+        private?: boolean;
+    };
+    codeSettingPath: string;
+    codeInsiderSettingPath: string;
+}>;
 /**
  * List of supported client names.
  */

package/dist/core/installers/clients/ExtensionInstaller.js

@@ -128,6 +128,9 @@ export class ExtensionInstaller {
                 else {
                     // Install private extension from GitHub release using latest version
                     try {
+                        if (!repository || !assetName) {
+                            throw new Error(`Missing repository or assetName for private extension ${extensionId}`);
+                        }
                         const { resolvedPath } = await handleGitHubRelease({ name: extensionId, version: 'latest', type: 'extension' }, { repository, assetName });
                         success = await this.installPrivateExtension(resolvedPath, isInsiders);
                     }

package/dist/core/types.d.ts

@@ -73,6 +73,7 @@ export interface UpdateRequirementOptions {
 }
 export interface ServerUninstallOptions {
     removeData?: boolean;
+    targets?: string[];
 }
 export interface EnvVariableConfig {
     Required: boolean;
@@ -130,6 +131,10 @@ export interface FeedConfiguration {
     requirements: RequirementConfig[];
     mcpServers: McpConfig[];
 }
+export interface ClientSettings {
+    codeSettingPath: string;
+    codeInsiderSettingPath: string;
+}
 export declare enum MCPEvent {
     SERVER_INSTALLED = "server:installed",
     SERVER_UNINSTALLED = "server:uninstalled",
@@ -143,6 +148,7 @@ export interface MCPEventData {
     };
     [MCPEvent.SERVER_UNINSTALLED]: {
         serverName: string;
+        targets?: string[];
     };
     [MCPEvent.SERVER_STARTED]: {
         server: MCPServerCategory;

package/dist/services/ServerService.d.ts

@@ -27,11 +27,17 @@ export declare class ServerService {
      * Installs a specific mcp tool for a server.
      * TODO: This might require enhancing MCPManager to handle category-specific installs.
      */
+    /**
+     * Uninstall MCP server from specified client targets
+     * @param category The server category
+     * @param serverName The server name to uninstall
+     * @param options Uninstall options including target clients and data removal flags
+     */
     uninstallMcpServer(category: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
     /**
      * Validates server names
      */
-    validateServerName(category: string, name: string): Promise<boolean>;
+    validateServerName(category: string, names: string | string[]): Promise<boolean>;
     /**
      * Formats success/error messages for operations
      */

package/dist/services/ServerService.js

@@ -117,25 +117,40 @@ export class ServerService {
      * Installs a specific mcp tool for a server.
      * TODO: This might require enhancing MCPManager to handle category-specific installs.
      */
-    async uninstallMcpServer(category, serverName, options = {} // Reuse ServerInstallOptions for env etc.
-    ) {
-        return mcpManager.uninstallServer(category, serverName, options);
+    /**
+     * Uninstall MCP server from specified client targets
+     * @param category The server category
+     * @param serverName The server name to uninstall
+     * @param options Uninstall options including target clients and data removal flags
+     */
+    async uninstallMcpServer(category, serverName, options = {}) {
+        Logger.debug(`Uninstalling MCP server: ${JSON.stringify({ category, serverName, options })}`);
+        try {
+            const result = await mcpManager.uninstallServer(category, serverName, options);
+            Logger.debug(`Uninstallation result: ${JSON.stringify(result)}`);
+            return result;
+        }
+        catch (error) {
+            Logger.error(`Failed to uninstall MCP server: ${serverName}`, error);
+            throw error;
+        }
     }
     /**
      * Validates server names
      */
-    async validateServerName(category, name) {
-        Logger.debug(`Validating server name: ${JSON.stringify({ category, name })}`);
+    async validateServerName(category, names) {
+        const serverNames = Array.isArray(names) ? names : [names];
+        Logger.debug(`Validating server names: ${JSON.stringify({ category, names: serverNames })}`);
         // Check if category exists in feeds
         const feedConfig = await mcpManager.getFeedConfiguration(category);
         if (!feedConfig) {
             Logger.debug(`Validation failed: Category "${category}" not found in feeds`);
             return false;
         }
-        // Check if server exists in the category's mcpServers
-        const serverExists = feedConfig.mcpServers.some(server => server.name === name);
-        if (!serverExists) {
-            Logger.debug(`Validation failed: Server "${name}" not found in category "${category}"`);
+        // Check if all servers exist in the category's mcpServers
+        const invalidServers = serverNames.filter(name => !feedConfig.mcpServers.some(server => server.name === name));
+        if (invalidServers.length > 0) {
+            Logger.debug(`Validation failed: Servers "${invalidServers.join(', ')}" not found in category "${category}"`);
             return false;
         }
         return true;

package/dist/utils/osUtils.js

@@ -256,7 +256,7 @@ export function getPythonPackagePath(pythonExecutablePath) {
                 const venvRoot = path.dirname(dir);
                 return path.join(venvRoot, 'Lib', 'site-packages');
             }
-            else if (dir.toLowerCase().includes('python')) {
+            else {
                 // System Python or Conda on Windows
                 return path.join(dir, 'Lib', 'site-packages');
             }