imcp 0.0.4 → 0.0.6

package/README.md

@@ -1,14 +1,13 @@
 # IMCP
 
-IMCP is a single-line pull ann push experience that makes onboarding MCP servers easy.
+IMCP is a single-line pull and push experience that makes onboarding MCP servers easy.
 
 ## Overview
 
 IMCP allows you to:
 
-- Discover available MCP servers
-- Manage server installations
-- Run a local web interface with simple click experience
+- Discover and install available MCP servers to your local agents
+- Run a local UI interface with simple click experience to manage MCP servers
 - (in progress) Distribute your own MCP servers to others
 
 ## Installation

package/dist/cli/commands/install.js

@@ -3,6 +3,7 @@ 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';
 export function createInstallCommand() {
     return new Command('install')
         .description('Install specific MCP servers')
@@ -29,6 +30,7 @@ Examples:
                 Logger.log('Local feeds not found, syncing from remote...');
                 await serverService.syncFeeds();
             }
+            await mcpManager.initialize();
             const { category, name, verbose, clients, envs } = options;
             Logger.debug(`Install options: ${JSON.stringify({ category, name, verbose, clients, envs })}`);
             const serverName = name.trim();

package/dist/cli/commands/list.js

@@ -23,6 +23,7 @@ export function createListCommand() {
                     Logger.error('Failed to sync feeds, falling back to local feeds', syncError);
                 }
             }
+            await mcpManager.initialize();
             Logger.debug({
                 action: 'ensuring_feeds_directory',
                 path: LOCAL_FEEDS_DIR

package/dist/cli/index.js

@@ -4,7 +4,6 @@ import { createServeCommand } from './commands/serve.js';
 import { createListCommand } from './commands/list.js';
 import { createInstallCommand } from './commands/install.js';
 import { createPullCommand } from './commands/pull.js';
-import { mcpManager } from '../core/MCPManager.js';
 import { Logger } from '../utils/logger.js';
 import axios from 'axios';
 import path from 'path';
@@ -19,7 +18,7 @@ const COLORS = {
 };
 async function main() {
     // Initialize the MCP manager
-    await mcpManager.initialize();
+    // await mcpManager.initialize();
     const program = new Command();
     program
         .name('imcp')

package/dist/core/ConfigurationLoader.d.ts

@@ -0,0 +1,32 @@
+import { MCPConfiguration } from './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): Promise<MCPConfiguration>;
+    /**
+     * Loads MCP client settings into the configuration
+     */
+    static loadClientMCPSettings(configuration: MCPConfiguration): Promise<MCPConfiguration>;
+}

package/dist/core/ConfigurationLoader.js

@@ -0,0 +1,213 @@
+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';
+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) {
+        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 < Object.keys(server.feedConfiguration?.mcpServers || []).length) {
+                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 = {
+                    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) {
+        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 = {};
+            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;
+                    }
+                }
+                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/ConfigurationProvider.d.ts

@@ -9,7 +9,6 @@ export declare class ConfigurationProvider {
     static getInstance(): ConfigurationProvider;
     private withLock;
     initialize(): Promise<void>;
-    private loadClientMCPSettings;
     private saveConfiguration;
     getServerCategories(): Promise<MCPServerCategory[]>;
     getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;
@@ -27,7 +26,7 @@ export declare class ConfigurationProvider {
     isServerReady(categoryName: string, serverName: string, clients: string[]): Promise<boolean>;
     syncFeeds(): Promise<void>;
     private loadFeedsIntoConfiguration;
-    private syncServerCategoriesWithFeeds;
-    syncWithFeed(feedConfiguration: Record<string, FeedConfiguration>): Promise<void>;
+    private loadClientMCPSettings;
+    reloadClientMCPSettings(): Promise<void>;
 }
 export declare const configProvider: ConfigurationProvider;

package/dist/core/ConfigurationProvider.js

@@ -3,10 +3,10 @@ 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, 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 { readJsonFile } from '../utils/clientUtils.js';
+import { ConfigurationLoader } from './ConfigurationLoader.js';
 const execAsync = promisify(exec);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export class ConfigurationProvider {
@@ -62,45 +62,6 @@ export class ConfigurationProvider {
             }
         });
     }
-    async loadClientMCPSettings() {
-        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') {
-                        // 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;
-        }
-    }
     async saveConfiguration() {
         const configDir = path.dirname(this.configPath);
         await fs.mkdir(configDir, { recursive: true });
@@ -295,7 +256,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 {
                     await fs.access(sourceFeedsDir);
@@ -303,10 +264,8 @@ export class ConfigurationProvider {
                 catch (err) {
                     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);
@@ -315,145 +274,17 @@ export class ConfigurationProvider {
         });
     }
     async loadFeedsIntoConfiguration() {
-        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 = {};
-            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;
-                    }
-                }
-                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();
     }
-    async syncServerCategoriesWithFeeds() {
-        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 = {};
-                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: {} // 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 = {
-                    name: feedName,
-                    displayName: feedConfig.displayName || feedName,
-                    type: 'local',
-                    description: feedConfig.description || `Local MCP server category: ${feedName}`,
-                    installationStatus: (() => {
-                        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: {} // 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();
-        }
+    async loadClientMCPSettings() {
+        this.configuration = await ConfigurationLoader.loadClientMCPSettings(this.configuration);
+        await this.saveConfiguration();
     }
-    async syncWithFeed(feedConfiguration) {
-        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() {
+        return await this.withLock(async () => {
+            await this.loadClientMCPSettings();
         });
     }
 }

package/dist/core/InstallationService.d.ts

@@ -22,4 +22,12 @@ export declare class InstallationService {
      * @param requirements The requirements to update
      */
     private processRequirementUpdates;
+    /**
+     * Checks and installs requirements for a server if needed
+     * @param categoryName The category name
+     * @param serverName The server name
+     * @param options The installation options
+     * @returns A failure result if requirements check fails, null if requirements are satisfied
+     */
+    private checkAndInstallRequirements;
 }