imcp 0.0.3 → 0.0.5

package/src/core/ConfigurationLoader.ts

@@ -0,0 +1,251 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_DIR, SUPPORTED_CLIENTS } from './constants.js';
+import { Logger } from '../utils/logger.js';
+import { readJsonFile } from '../utils/clientUtils.js';
+import {
+    MCPConfiguration,
+    MCPServerCategory,
+    MCPServerStatus,
+    OperationStatus,
+    FeedConfiguration,
+    RequirementStatus,
+    InstallationStatus
+} from './types.js';
+
+export class ConfigurationLoader {
+    /**
+     * Updates the installed status for a server and client combination
+     */
+    private static updateServerInstalledStatus(
+        serverStatus: MCPServerStatus,
+        clientName: string,
+        operationStatus: OperationStatus
+    ): void {
+        if (!serverStatus.installedStatus) {
+            serverStatus.installedStatus = {};
+        }
+        serverStatus.installedStatus[clientName] = operationStatus;
+    }
+
+    /**
+     * Removes a client's status from a server
+     */
+    private static removeClientStatus(
+        serverStatus: MCPServerStatus,
+        clientName: string
+    ): void {
+        if (serverStatus.installedStatus && serverStatus.installedStatus[clientName]) {
+            delete serverStatus.installedStatus[clientName];
+        }
+    }
+
+    /**
+     * Synchronizes server categories with client MCP settings.
+     * Uses clientMCPSettings as source of truth for installation status.
+     */
+    static syncServerCategoriesWithClientSettings(configuration: MCPConfiguration): MCPConfiguration {
+        if (!configuration.clientMCPSettings) {
+            return configuration;
+        }
+
+        configuration.localServerCategories = configuration.localServerCategories.map(category => {
+            if (!category.installationStatus?.serversStatus) {
+                return category;
+            }
+
+            const updatedServerStatus = { ...category.installationStatus.serversStatus };
+            const clientSettings = configuration.clientMCPSettings as Record<string, Record<string, any>>;
+
+            for (const [clientName, settings] of Object.entries(clientSettings)) {
+                const clientServers = clientName === 'GithubCopilot'
+                    ? settings.servers || {}
+                    : settings.mcpServers || {};
+
+                Object.keys(updatedServerStatus).forEach(serverName => {
+                    if (clientServers[serverName]) {
+                        if (!updatedServerStatus[serverName].installedStatus[clientName]) {
+                            const operationStatus: OperationStatus = {
+                                status: 'completed',
+                                type: 'install',
+                                target: 'server',
+                                message: `Server ${serverName} is configured for client ${clientName}`
+                            };
+                            ConfigurationLoader.updateServerInstalledStatus(updatedServerStatus[serverName], clientName, operationStatus);
+                        }
+                    } else {
+                        ConfigurationLoader.removeClientStatus(updatedServerStatus[serverName], clientName);
+                    }
+                });
+            }
+
+            return {
+                ...category,
+                installationStatus: {
+                    ...category.installationStatus,
+                    serversStatus: updatedServerStatus,
+                    lastUpdated: new Date().toISOString()
+                }
+            };
+        });
+
+        return configuration;
+    }
+
+    /**
+     * Initializes installation status for a feed configuration
+     */
+    private static initializeInstallationStatus(feedConfig?: FeedConfiguration): InstallationStatus {
+        const requirementsStatus: Record<string, RequirementStatus> = {};
+        const serversStatus: Record<string, MCPServerStatus> = {};
+
+        if (feedConfig) {
+            if (feedConfig.requirements) {
+                for (const req of feedConfig.requirements) {
+                    requirementsStatus[req.name] = {
+                        name: req.name,
+                        type: req.type,
+                        installed: false,
+                        version: req.version,
+                        error: undefined
+                    };
+                }
+            }
+            if (feedConfig.mcpServers) {
+                for (const mcp of feedConfig.mcpServers) {
+                    serversStatus[mcp.name] = {
+                        name: mcp.name,
+                        error: undefined,
+                        installedStatus: {}
+                    };
+                }
+            }
+        }
+
+        return {
+            requirementsStatus,
+            serversStatus,
+            lastUpdated: new Date().toISOString()
+        };
+    }
+
+    /**
+     * Synchronizes server categories with feeds
+     */
+    private static async syncServerCategoriesWithFeeds(configuration: MCPConfiguration): Promise<MCPConfiguration> {
+        configuration.localServerCategories = configuration.localServerCategories.map(server => {
+            if (configuration.feeds[server.name]) {
+                server.feedConfiguration = configuration.feeds[server.name];
+            }
+
+            if (
+                !server.installationStatus ||
+                !server.installationStatus.requirementsStatus ||
+                Object.keys(server.installationStatus.requirementsStatus).length === 0 ||
+                !server.installationStatus.serversStatus ||
+                Object.keys(server.installationStatus.serversStatus).length === 0
+            ) {
+                server.installationStatus = ConfigurationLoader.initializeInstallationStatus(server.feedConfiguration);
+            }
+
+            return server;
+        });
+
+        const existingServerNames = new Set(configuration.localServerCategories.map(category => category.name));
+
+        for (const [feedName, feedConfig] of Object.entries(configuration.feeds)) {
+            if (!existingServerNames.has(feedName)) {
+                const newServerCategory: MCPServerCategory = {
+                    name: feedName,
+                    displayName: feedConfig.displayName || feedName,
+                    type: 'local',
+                    description: feedConfig.description || `Local MCP server category: ${feedName}`,
+                    installationStatus: ConfigurationLoader.initializeInstallationStatus(feedConfig),
+                    feedConfiguration: feedConfig
+                };
+
+                configuration.localServerCategories.push(newServerCategory);
+                console.log(`Created new local server entry for feed: ${feedName}`);
+            }
+        }
+
+        return configuration;
+    }
+
+    /**
+     * Loads feed configurations into the MCP configuration
+     */
+    static async loadFeedsIntoConfiguration(configuration: MCPConfiguration): Promise<MCPConfiguration> {
+        try {
+            await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+            const files = await fs.readdir(LOCAL_FEEDS_DIR);
+            const jsonFiles = files.filter(file => file.endsWith('.json'));
+
+            if (jsonFiles.length === 0) {
+                console.log(`No feed configuration files found in ${LOCAL_FEEDS_DIR}`);
+                return configuration;
+            }
+
+            const feeds: Record<string, FeedConfiguration> = {};
+            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) as FeedConfiguration;
+                    if (config && config.name) {
+                        feeds[config.name] = config;
+                    }
+                } catch (error) {
+                    console.warn(`Error loading feed configuration from ${file}:`, error);
+                }
+            }
+
+            configuration.feeds = feeds;
+            return await ConfigurationLoader.syncServerCategoriesWithFeeds(configuration);
+        } catch (error) {
+            console.error("Error loading feed configurations:", error);
+            throw error;
+        }
+    }
+
+    /**
+     * Loads MCP client settings into the configuration
+     */
+    static async loadClientMCPSettings(configuration: MCPConfiguration): Promise<MCPConfiguration> {
+        try {
+            Logger.debug('Starting to load MCP client settings...');
+            const settings: Record<string, Record<string, any>> = {};
+
+            for (const [clientName, clientSettings] of Object.entries(SUPPORTED_CLIENTS)) {
+                const settingPath = process.env.CODE_INSIDERS
+                    ? clientSettings.codeInsiderSettingPath
+                    : clientSettings.codeSettingPath;
+                try {
+                    let content = await readJsonFile(settingPath, true);
+
+                    if (clientName === 'GithubCopilot') {
+                        if (!content.mcp) {
+                            content = {
+                                servers: {},
+                                inputs: []
+                            };
+                        } else {
+                            content = content.mcp;
+                        }
+                    }
+                    settings[clientName] = content;
+                    Logger.debug(`Successfully loaded MCP settings for ${clientName}`);
+                } catch (error) {
+                    Logger.debug(`Warning: Could not load MCP settings for client ${clientName}: ${error instanceof Error ? error.message : String(error)}`);
+                    settings[clientName] = {};
+                }
+            }
+
+            configuration.clientMCPSettings = settings;
+            return ConfigurationLoader.syncServerCategoriesWithClientSettings(configuration);
+        } catch (error) {
+            Logger.error('Error loading client MCP settings:', error);
+            throw error;
+        }
+    }
+}

package/src/core/ConfigurationProvider.ts

@@ -1,10 +1,9 @@
 import fs from 'fs/promises';
 import path from 'path';
-import os from 'os';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
-import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR, SUPPORTED_CLIENTS } from './constants.js';
+import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR } from './constants.js';
 import { Logger } from '../utils/logger.js';
 import { checkGithubAuth } from '../utils/githubAuth.js';
 import {
@@ -16,7 +15,7 @@ import {
     MCPServerStatus,
     OperationStatus
 } from './types.js';
-import { readJsonFile } from '../utils/clientUtils.js';
+import { ConfigurationLoader } from './ConfigurationLoader.js';
 
 const execAsync = promisify(exec);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -78,46 +77,6 @@ export class ConfigurationProvider {
         });
     }
 
-    private async loadClientMCPSettings(): Promise<void> {
-        try {
-            Logger.debug('Starting to load MCP client settings...');
-            const settings: Record<string, Record<string, any>> = {};
-
-            for (const [clientName, clientSettings] of Object.entries(SUPPORTED_CLIENTS)) {
-                const settingPath = process.env.CODE_INSIDERS
-                    ? clientSettings.codeInsiderSettingPath
-                    : clientSettings.codeSettingPath;
-                try {
-                    let content = await readJsonFile(settingPath, true);
-
-                    if (clientName === 'GithubCopilot') {
-                        // Initialize the mcp section if it doesn't exist
-                        if (!content.mcp) {
-                            content = {
-                                servers: {},
-                                inputs: []
-                            };
-                        } else {
-                            content = content.mcp;
-                        }
-                    }
-                    settings[clientName] = content;
-                    Logger.debug(`Successfully loaded MCP settings for ${clientName}`);
-                } catch (error) {
-                    Logger.debug(`Warning: Could not load MCP settings for client ${clientName}: ${error instanceof Error ? error.message : String(error)}`);
-                    settings[clientName] = {};
-                }
-            }
-
-            this.configuration.clientMCPSettings = settings;
-            await this.saveConfiguration();
-            Logger.debug('Saved MCP client settings to configuration');
-        } catch (error) {
-            Logger.error('Error loading client MCP settings:', error);
-            throw error;
-        }
-    }
-
     private async saveConfiguration(): Promise<void> {
         const configDir = path.dirname(this.configPath);
         await fs.mkdir(configDir, { recursive: true });
@@ -355,7 +314,7 @@ export class ConfigurationProvider {
                 }
 
                 Logger.debug('Updating local feeds...');
-                await fs.rm(LOCAL_FEEDS_DIR, { recursive: true, force: true });
+                // await fs.rm(LOCAL_FEEDS_DIR, { recursive: true, force: true });
                 const sourceFeedsDir = path.join(this.tempDir, GITHUB_REPO.feedsPath);
 
                 try {
@@ -364,11 +323,9 @@ export class ConfigurationProvider {
                     throw new Error(`Could not find feeds directory in cloned repository: ${sourceFeedsDir}`);
                 }
 
-                await fs.cp(sourceFeedsDir, LOCAL_FEEDS_DIR, { recursive: true });
+                await fs.cp(sourceFeedsDir, LOCAL_FEEDS_DIR, { recursive: true, force: true });
                 Logger.log('Successfully updated local feeds');
 
-                // Update configuration with new feeds
-                await this.loadFeedsIntoConfiguration();
             } catch (error) {
                 Logger.error('Error during feed synchronization', error);
                 throw new Error('Failed to sync feeds. Use --verbose for detailed error information.');
@@ -377,158 +334,19 @@ export class ConfigurationProvider {
     }
 
     private async loadFeedsIntoConfiguration(): Promise<void> {
-        try {
-            await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
-            const files = await fs.readdir(LOCAL_FEEDS_DIR);
-            const jsonFiles = files.filter(file => file.endsWith('.json'));
-
-            if (jsonFiles.length === 0) {
-                console.log(`No feed configuration files found in ${LOCAL_FEEDS_DIR}`);
-                return;
-            }
-
-            const feeds: Record<string, FeedConfiguration> = {};
-            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) as FeedConfiguration;
-                    if (config && config.name) {
-                        feeds[config.name] = config;
-                    }
-                } catch (error) {
-                    console.warn(`Error loading feed configuration from ${file}:`, error);
-                }
-            }
-
-            this.configuration.feeds = feeds;
-            await this.syncServerCategoriesWithFeeds(); // Sync categories after loading feeds
-            await this.saveConfiguration();
-        } catch (error) {
-            console.error("Error loading feed configurations:", error);
-            throw error;
-        }
+        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration);
+        await this.saveConfiguration();
     }
 
-    private async syncServerCategoriesWithFeeds(): Promise<void> {
-        let configUpdated = false;
-
-        // 1. Process existing local servers - update their feed configurations
-        for (const server of this.configuration.localServerCategories) {
-            if (this.configuration.feeds[server.name]) {
-                server.feedConfiguration = this.configuration.feeds[server.name];
-                configUpdated = true;
-            }
-
-            // If server doesn't have installation status, initialize it
-            const feedConfig = server.feedConfiguration;
-            // If installationStatus is missing, or requirements/tools are empty, initialize from feed
-            if (
-                !server.installationStatus ||
-                !server.installationStatus.requirementsStatus ||
-                Object.keys(server.installationStatus.requirementsStatus).length === 0 ||
-                !server.installationStatus.serversStatus ||
-                Object.keys(server.installationStatus.serversStatus).length === 0
-            ) {
-                const requirementsStatus: Record<string, RequirementStatus> = {};
-                const serversStatus: Record<string, MCPServerStatus> = {};
-                if (feedConfig) {
-                    if (feedConfig.requirements) {
-                        for (const req of feedConfig.requirements) {
-                            requirementsStatus[req.name] = {
-                                name: req.name,
-                                type: req.type,
-                                installed: false,
-                                version: req.version,
-                                error: undefined
-                            };
-                        }
-                    }
-                    if (feedConfig.mcpServers) {
-                        for (const mcp of feedConfig.mcpServers) {
-                            serversStatus[mcp.name] = {
-                                name: mcp.name,
-                                error: undefined,
-                                installedStatus: {} // Add missing property
-                            };
-                        }
-                    }
-                }
-                server.installationStatus = {
-                    requirementsStatus,
-                    serversStatus,
-                    lastUpdated: new Date().toISOString()
-                };
-                configUpdated = true;
-            }
-        }
-
-        // 2. Check for feeds that don't have a corresponding local server and create new entries
-        const existingServerCategoryNames = new Set(this.configuration.localServerCategories.map(catetory => catetory.name));
-
-        for (const feedName in this.configuration.feeds) {
-            if (!existingServerCategoryNames.has(feedName)) {
-                // This feed doesn't have a corresponding local server - create one with empty installation status
-                const feedConfig = this.configuration.feeds[feedName];
-
-                // Create new server with empty installation status
-                const newServerCategory: MCPServerCategory = {
-                    name: feedName,
-                    displayName: feedConfig.displayName || feedName,
-                    type: 'local',
-                    description: feedConfig.description || `Local MCP server category: ${feedName}`,
-                    installationStatus: (() => {
-                        const requirementsStatus: Record<string, RequirementStatus> = {};
-                        const serversStatus: Record<string, MCPServerStatus> = {};
-                        if (feedConfig) {
-                            if (feedConfig.requirements) {
-                                for (const req of feedConfig.requirements) {
-                                    requirementsStatus[req.name] = {
-                                        name: req.name,
-                                        type: req.type,
-                                        installed: false,
-                                        version: req.version,
-                                        error: undefined
-                                    };
-                                }
-                            }
-                            if (feedConfig.mcpServers) {
-                                for (const mcp of feedConfig.mcpServers) {
-                                    serversStatus[mcp.name] = {
-                                        name: mcp.name,
-                                        error: undefined,
-                                        installedStatus: {} // Add missing property
-                                    };
-                                }
-                            }
-                        }
-                        return {
-                            requirementsStatus,
-                            serversStatus,
-                            lastUpdated: new Date().toISOString()
-                        };
-                    })(),
-                    feedConfiguration: feedConfig
-                };
-
-                // Add the new server to the configuration
-                this.configuration.localServerCategories.push(newServerCategory);
-                console.log(`Created new local server entry for feed: ${feedName}`);
-                configUpdated = true;
-            }
-        }
-
-        if (configUpdated) {
-            await this.saveConfiguration();
-        }
+    private async loadClientMCPSettings(): Promise<void> {
+        this.configuration = await ConfigurationLoader.loadClientMCPSettings(this.configuration);
+        await this.saveConfiguration();
     }
 
-
-    async syncWithFeed(feedConfiguration: Record<string, FeedConfiguration>): Promise<void> {
-        await this.withLock(async () => {
-            this.configuration.feeds = feedConfiguration;
-            await this.syncServerCategoriesWithFeeds(); // Sync categories after direct update
-            await this.saveConfiguration();
+    // Public method to reload client MCP settings
+    async reloadClientMCPSettings(): Promise<void> {
+        return await this.withLock(async () => {
+            await this.loadClientMCPSettings();
         });
     }
 }