imcp 0.0.16 → 0.0.17

package/dist/cli/commands/install.js

@@ -2,8 +2,8 @@ import { Command } from 'commander';
 import { serverService } from '../../services/ServerService.js';
 import { Logger } from '../../utils/logger.js';
 import { hasLocalFeeds } from '../../utils/feedUtils.js';
-import { SUPPORTED_CLIENT_NAMES } from '../../core/constants.js';
-import { mcpManager } from '../../core/MCPManager.js';
+import { SUPPORTED_CLIENT_NAMES } from '../../core/metadatas/constants.js';
+import { mcpManager } from '../../services/MCPManager.js';
 export function createInstallCommand() {
     return new Command('install')
         .description('Install specific MCP servers')

package/dist/cli/commands/list.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
 import fs from 'fs/promises';
 import path from 'path';
-import { LOCAL_FEEDS_DIR } from '../../core/constants.js';
-import { mcpManager } from '../../core/MCPManager.js';
+import { LOCAL_FEEDS_DIR } from '../../core/metadatas/constants.js';
+import { mcpManager } from '../../services/MCPManager.js';
 import { Logger } from '../../utils/logger.js';
 export function createListCommand() {
     return new Command('list')

package/dist/cli/commands/serve.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { startWebServer } from '../../web/server.js';
-import { mcpManager } from '../../core/MCPManager.js';
+import { mcpManager } from '../../services/MCPManager.js';
 export function createServeCommand() {
     return new Command('serve')
         .description('Serve local web interface')

package/dist/core/RequirementService.d.ts

@@ -11,12 +11,6 @@ export declare class RequirementService {
      * @returns The RequirementService instance
      */
     static getInstance(): RequirementService;
-    /**
-     * Install a requirement
-     * @param requirement The requirement to install
-     * @returns The installation status
-     */
-    installRequirement(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     /**
      * Check the installation status of a requirement
      * @param requirement The requirement to check
@@ -36,12 +30,6 @@ export declare class RequirementService {
      * @returns The updated requirement status
      */
     updateRequirement(requirement: RequirementConfig, updateVersion: string, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    /**
-     * Install multiple requirements
-     * @param requirements The requirements to install
-     * @returns A map of requirement names to their installation status
-     */
-    installRequirements(requirements: RequirementConfig[]): Promise<Record<string, RequirementStatus>>;
     /**
      * Validate a requirement configuration
      * @param requirement The requirement to validate

package/dist/core/RequirementService.js

@@ -18,17 +18,6 @@ export class RequirementService {
         }
         return RequirementService.instance;
     }
-    /**
-     * Install a requirement
-     * @param requirement The requirement to install
-     * @returns The installation status
-     */
-    async installRequirement(requirement, options) {
-        // Validate requirement
-        this.validateRequirement(requirement);
-        // Install the requirement
-        return await this.installerFactory.install(requirement, options);
-    }
     /**
      * Check the installation status of a requirement
      * @param requirement The requirement to check
@@ -78,19 +67,6 @@ export class RequirementService {
         // Install the updated version
         return await this.installerFactory.install(updatedRequirement, options);
     }
-    /**
-     * Install multiple requirements
-     * @param requirements The requirements to install
-     * @returns A map of requirement names to their installation status
-     */
-    async installRequirements(requirements) {
-        const results = {};
-        // Process each requirement sequentially to avoid conflicts
-        for (const requirement of requirements) {
-            results[requirement.name] = await this.installRequirement(requirement);
-        }
-        return results;
-    }
     /**
      * Validate a requirement configuration
      * @param requirement The requirement to validate

package/dist/core/installers/clients/BaseClientInstaller.d.ts

@@ -1,4 +1,4 @@
-import { OperationStatus, McpConfig, ServerInstallOptions } from '../../types.js';
+import { OperationStatus, McpConfig, ServerInstallOptions } from '../../metadatas/types.js';
 /**
  * Base class for client installers with shared functionality
  */

package/dist/core/installers/clients/ClientInstaller.d.ts

@@ -1,4 +1,4 @@
-import { ServerOperationResult, ServerInstallOptions } from '../../types.js';
+import { ServerOperationResult, ServerInstallOptions } from '../../metadatas/types.js';
 /**
  * Main client installer class that orchestrates client installation process
  * Handles requirements checking and delegates to specific client installers

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

@@ -1,4 +1,4 @@
-import { ConfigurationProvider } from '../../ConfigurationProvider.js';
+import { ConfigurationProvider } from '../../loaders/ConfigurationProvider.js';
 import { ClientInstallerFactory } from './ClientInstallerFactory.js';
 /**
  * Main client installer class that orchestrates client installation process

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

@@ -1,7 +1,7 @@
 import { MSRooCodeInstaller } from './MSRooCodeInstaller.js';
 import { ClineInstaller } from './ClineInstaller.js';
 import { GithubCopilotInstaller } from './GithubCopilotInstaller.js';
-import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 /**
  * Factory for creating client-specific installers
  * Handles creation of appropriate installer based on client type

package/dist/core/installers/clients/ClineInstaller.d.ts

@@ -1,5 +1,5 @@
 import { BaseClientInstaller } from './BaseClientInstaller.js';
-import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../metadatas/types.js';
 /**
  * Cline client installer implementation
  * Handles installation of Cline client including extension installation and settings configuration

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

@@ -2,7 +2,7 @@ import { BaseClientInstaller } from './BaseClientInstaller.js';
 import { Logger } from '../../../utils/logger.js';
 import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
 import { ExtensionInstaller } from './ExtensionInstaller.js';
-import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 import { isCommandAvailable } from '../../../utils/osUtils.js';
 /**
  * Cline client installer implementation

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

@@ -1,6 +1,6 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 import { Logger } from '../../../utils/logger.js';
 import { handleGitHubRelease } from '../../../utils/githubUtils.js';
 import { compareVersions } from '../../../utils/versionUtils.js';

package/dist/core/installers/clients/GithubCopilotInstaller.d.ts

@@ -1,5 +1,5 @@
 import { BaseClientInstaller } from './BaseClientInstaller.js';
-import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../metadatas/types.js';
 /**
  * Github Copilot client installer implementation
  * Handles installation of Github Copilot client including extension installation and settings configuration

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

@@ -2,7 +2,7 @@ import { BaseClientInstaller } from './BaseClientInstaller.js';
 import { Logger } from '../../../utils/logger.js';
 import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
 import { ExtensionInstaller } from './ExtensionInstaller.js';
-import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 import { isCommandAvailable } from '../../../utils/osUtils.js';
 /**
  * Github Copilot client installer implementation

package/dist/core/installers/clients/MSRooCodeInstaller.d.ts

@@ -1,5 +1,5 @@
 import { BaseClientInstaller } from './BaseClientInstaller.js';
-import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../metadatas/types.js';
 /**
  * MSRooCode client installer implementation
  */

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

@@ -2,7 +2,7 @@ import { BaseClientInstaller } from './BaseClientInstaller.js';
 import { Logger } from '../../../utils/logger.js';
 import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
 import { ExtensionInstaller } from './ExtensionInstaller.js';
-import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 import { isCommandAvailable } from '../../../utils/osUtils.js';
 /**
  * MSRooCode client installer implementation

package/dist/core/installers/requirements/BaseInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 /**
  * Abstract base class with common functionality for all requirement installers

package/dist/core/installers/requirements/BaseInstaller.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { SETTINGS_DIR } from '../../constants.js';
+import { SETTINGS_DIR } from '../../metadatas/constants.js';
 import { Logger } from '../../../utils/logger.js';
 /**
  * Abstract base class with common functionality for all requirement installers

package/dist/core/installers/requirements/CommandInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for command-line tools

package/dist/core/installers/requirements/CommandInstaller.js

@@ -1,4 +1,4 @@
-import { OSType } from '../../types.js';
+import { OSType } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 import { getOSType, refreshPathEnv } from '../../../utils/osUtils.js';
 import { Logger } from '../../../utils/logger.js';

package/dist/core/installers/requirements/GeneralInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for general requirements (type 'other')

package/dist/core/installers/requirements/InstallerFactory.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 import { exec } from 'child_process';
 /**

package/dist/core/installers/requirements/NpmInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for NPM packages

package/dist/core/installers/requirements/NpmInstaller.js

@@ -5,7 +5,7 @@ import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/gith
 import { handleArtifact as handleAdoArtifact, getArtifactLatestVersion } from '../../../utils/adoUtils.js';
 import path from 'path';
 import fs from 'fs/promises';
-import { SETTINGS_DIR } from '../../constants.js'; // Corrected path
+import { SETTINGS_DIR } from '../../metadatas/constants.js'; // Corrected path
 import { Logger } from '../../../utils/logger.js';
 /**
  * Installer implementation for NPM packages

package/dist/core/installers/requirements/PipInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 import { BaseInstaller } from './BaseInstaller.js';
 /**
  * Installer implementation for Python packages using pip

package/dist/core/installers/requirements/RequirementInstaller.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
 /**
  * Interface for requirement installers.
  * Implementations should handle specific requirement types.

package/dist/core/loaders/ConfigurationLoader.d.ts

@@ -0,0 +1,32 @@
+import { MCPConfiguration } from '../metadatas/types.js';
+export declare class ConfigurationLoader {
+    /**
+     * Updates the installed status for a server and client combination
+     */
+    private static updateServerInstalledStatus;
+    /**
+     * Removes a client's status from a server
+     */
+    private static removeClientStatus;
+    /**
+     * Synchronizes server categories with client MCP settings.
+     * Uses clientMCPSettings as source of truth for installation status.
+     */
+    static syncServerCategoriesWithClientSettings(configuration: MCPConfiguration): MCPConfiguration;
+    /**
+     * Initializes installation status for a feed configuration
+     */
+    private static initializeInstallationStatus;
+    /**
+     * Synchronizes server categories with feeds
+     */
+    private static syncServerCategoriesWithFeeds;
+    /**
+     * Loads feed configurations into the MCP configuration
+     */
+    static loadFeedsIntoConfiguration(configuration: MCPConfiguration, feedFile?: string): Promise<MCPConfiguration>;
+    /**
+     * Loads MCP client settings into the configuration
+     */
+    static loadClientMCPSettings(configuration: MCPConfiguration): Promise<MCPConfiguration>;
+}

package/dist/core/loaders/ConfigurationLoader.js

@@ -0,0 +1,236 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_DIR, SUPPORTED_CLIENTS } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { readJsonFile } from '../../utils/clientUtils.js';
+export class ConfigurationLoader {
+    /**
+     * Updates the installed status for a server and client combination
+     */
+    static updateServerInstalledStatus(serverStatus, clientName, operationStatus) {
+        if (!serverStatus.installedStatus) {
+            serverStatus.installedStatus = {};
+        }
+        serverStatus.installedStatus[clientName] = operationStatus;
+    }
+    /**
+     * Removes a client's status from a server
+     */
+    static removeClientStatus(serverStatus, clientName) {
+        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) {
+        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;
+            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 = {
+                                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
+     */
+    static initializeInstallationStatus(feedConfig) {
+        const requirementsStatus = {};
+        const serversStatus = {};
+        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
+     */
+    static async syncServerCategoriesWithFeeds(configuration) {
+        // Filter out categories that don't have corresponding feeds and update existing ones
+        configuration.localServerCategories = configuration.localServerCategories
+            .filter(server => configuration.feeds[server.name])
+            .map(server => {
+            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 < Object.keys(server.feedConfiguration?.mcpServers || []).length) {
+                server.installationStatus = ConfigurationLoader.initializeInstallationStatus(server.feedConfiguration);
+            }
+            return server;
+        });
+        // Add new categories for feeds that don't have a corresponding category
+        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 = {
+                    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, 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 && !feedFile) {
+                console.log(`No feed configuration files found in ${LOCAL_FEEDS_DIR}`);
+                return configuration;
+            }
+            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) {
+                        // 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) {
+                    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) {
+        try {
+            Logger.debug('Starting to load MCP client settings...');
+            const settings = {};
+            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;
+        }
+    }
+}
+//# sourceMappingURL=ConfigurationLoader.js.map

package/dist/core/loaders/ConfigurationProvider.d.ts

@@ -0,0 +1,35 @@
+import { MCPServerCategory, FeedConfiguration, InstallationStatus, RequirementStatus, MCPServerStatus, OperationStatus, McpConfig } from '../metadatas/types.js';
+export declare class ConfigurationProvider {
+    private static instance;
+    private configPath;
+    private configuration;
+    private configLock;
+    private tempDir;
+    private constructor();
+    static getInstance(): ConfigurationProvider;
+    private withLock;
+    initialize(feedFile?: string): Promise<void>;
+    private saveConfiguration;
+    getServerCategories(): Promise<MCPServerCategory[]>;
+    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>;
+    updateInstallationStatus(categoryName: string, requirementStatus: Record<string, RequirementStatus>, serverStatus: Record<string, MCPServerStatus>): Promise<boolean>;
+    updateRequirementStatus(categoryName: string, requirementName: string, status: RequirementStatus): Promise<boolean>;
+    updateRequirementOperationStatus(categoryName: string, requirementName: string, operationStatus: OperationStatus): Promise<boolean>;
+    updateServerStatus(categoryName: string, serverName: string, status: MCPServerStatus): Promise<boolean>;
+    updateServerOperationStatus(categoryName: string, serverName: string, clientName: string, operationStatus: OperationStatus): Promise<boolean>;
+    isRequirementsReady(categoryName: string, serverName: string): Promise<boolean>;
+    GetServerRequirementStatus(categoryName: string, serverName: string): Promise<RequirementStatus[]>;
+    isServerReady(categoryName: string, serverName: string, clients: string[]): Promise<boolean>;
+    syncFeeds(): Promise<void>;
+    private loadFeedsIntoConfiguration;
+    private loadClientMCPSettings;
+    reloadClientMCPSettings(): Promise<void>;
+    removeServerFromClientMCPSettings(serverName: string, target?: string): Promise<void>;
+}
+export declare const configProvider: ConfigurationProvider;