imcp 0.0.10 → 0.0.11

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

package/dist/core/ConfigurationProvider.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() {

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

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'events';
 import { ConfigurationProvider } from './ConfigurationProvider.js';
 import { InstallationService } from './InstallationService.js';
-import { MCPEvent } from './types.js';
+import { MCPEvent, } from './types.js';
 export class MCPManager extends EventEmitter {
     installationService;
     configProvider;
@@ -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);

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_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_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/web/public/css/detailsWidget.css

@@ -0,0 +1,103 @@
+.details-widget {
+    max-height: 0;
+    overflow: hidden;
+    transition: max-height 0.3s ease-out;
+}
+
+.details-widget.expanded {
+    max-height: 2000px;
+    transition: max-height 0.5s ease-in;
+}
+
+.details-widget-content {
+    padding: 1rem;
+    background-color: #f8fafc;
+    border-top: 1px solid #e2e8f0;
+}
+
+/* Schema specific styles */
+.schema-content {
+    font-family: system-ui, -apple-system, sans-serif;
+}
+
+.tool-section {
+    background-color: white;
+    border-radius: 0.5rem;
+    box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1);
+    margin-bottom: 1.5rem;
+    transition: transform 0.2s;
+}
+
+.tool-section:hover {
+    transform: translateY(-2px);
+}
+
+.property-item {
+    padding: 0.75rem;
+    margin: 0.5rem 0;
+    background-color: white;
+    border-radius: 0.375rem;
+    transition: all 0.2s;
+}
+
+.property-item:hover {
+    background-color: #f1f5f9;
+}
+
+.property-item.required {
+    border-left: 3px solid #3b82f6;
+}
+
+.property-name {
+    color: #1e40af;
+    font-weight: 600;
+}
+
+.property-type {
+    color: #64748b;
+    font-size: 0.875rem;
+}
+
+.property-desc {
+    color: #475569;
+    margin-top: 0.375rem;
+    line-height: 1.4;
+}
+
+.property-default {
+    color: #94a3b8;
+    font-size: 0.875rem;
+    font-family: monospace;
+}
+
+.required-badge {
+    background-color: #dbeafe;
+    color: #1e40af;
+    padding: 0.125rem 0.5rem;
+    border-radius: 9999px;
+    font-size: 0.75rem;
+    font-weight: 500;
+}
+
+.required-fields {
+    background-color: #fef3c7;
+    color: #92400e;
+    padding: 0.5rem;
+    border-radius: 0.375rem;
+    margin-bottom: 1rem;
+    font-size: 0.875rem;
+}
+
+.input-schema {
+    margin-top: 1rem;
+    padding: 1rem;
+    background-color: #f8fafc;
+    border-radius: 0.5rem;
+    border: 1px solid #e2e8f0;
+}
+
+.properties-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}

package/dist/web/public/css/serverDetails.css

@@ -6,16 +6,14 @@
 }
 
 .server-item-content {
+    position: relative;
     border: 1px solid #e5e7eb;
     border-radius: 0.5rem;
     padding: 1rem;
+    padding-right: calc(120px + 3rem); /* Button width + spacing */
     margin-bottom: 1rem;
     background-color: #ffffff;
     transition: all 0.2s ease;
-    position: relative;
-    display: flex;
-    justify-content: space-between;
-    align-items: bottom; /* Center items vertically */
 }
 
 .server-item:hover .server-item-content {
@@ -59,40 +57,53 @@
     border-color: #3b82f6;
 }
 
-/* Server item content layout */
+/* Server item layout */
 .server-item-info {
-    flex: 1;
-    padding-right: 1rem;
-    min-width: 0; /* Prevent content from overflowing */
-}
-
-/* Install/Uninstall buttons positioning */
-.action-buttons {
-    flex-shrink: 0;
-    display: flex;
-    align-items: center;
-    margin-left: 1rem; /* Add some space between content and button */
+    width: 100%;
 }
 
-/* Ensure buttons stay in place on hover */
-.server-item:hover .action-buttons {
-    position: relative;
-    z-index: 2;
+.server-item-header {
+    margin-bottom: 1rem;
 }
 
-/* Button styles */
-.action-buttons button {
-    white-space: nowrap;
-    padding: 0.5rem 1rem; /* Slightly larger padding for better visibility */
-    min-width: 80px; /* Ensure consistent button width */
-    text-align: center;
+.server-item-header h5 {
+    margin-bottom: 0.5rem;
 }
 
-/* Status badges layout */
-.server-item-info .flex-wrap {
+/* Client status section */
+.flex-wrap {
     margin: -0.25rem; /* Negative margin to offset badge spacing */
 }
 
-.server-item-info .flex-wrap > * {
+.flex-wrap > * {
     margin: 0.25rem; /* Even spacing between badges */
+}
+
+/* Install/Uninstall button section */
+.action-buttons {
+    position: absolute;
+    right: 1rem;
+    top: 50%;
+    transform: translateY(-50%);
+    margin: 0;
+}
+
+.action-buttons button {
+    min-width: 120px;
+    padding: 0.5rem 1.5rem;
+    text-align: center;
+    font-weight: 600;
+    transition: all 0.15s ease;
+    white-space: nowrap;
+}
+
+/* Status badges */
+.server-item-info .flex-wrap span {
+    display: inline-flex;
+    align-items: center;
+    padding: 0.375rem 0.75rem;
+    border-radius: 9999px;
+    font-size: 0.75rem;
+    line-height: 1;
+    white-space: nowrap;
 }

package/dist/web/public/js/detailsWidget.js

@@ -15,12 +15,101 @@ export class DetailsWidget {
         this.container.appendChild(this.widgetElement);
     }
 
-    setContent(description) {
-        this.contentElement.innerHTML = `
-            <div class="description-text">
-                ${description || 'No description available.'}
-            </div>
-        `;
+    setContent(content) {
+        if (typeof content === 'string') {
+            this.contentElement.innerHTML = `
+                <div class="description-text">
+                    ${content || 'No description available.'}
+                </div>
+            `;
+            return;
+        }
+
+        // If content is a schema object
+        if (content.schema) {
+            this.contentElement.innerHTML = this.renderSchema(content.schema);
+        }
+    }
+
+    renderSchema(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return '<p>Invalid schema format</p>';
+        }
+
+        // The schema object from the API is wrapped in a "schema" property
+        const schemaContent = schema.schema || schema;
+
+        let html = '<div class="schema-content p-4">';
+
+        // Iterate through each tool in schema
+        Object.entries(schemaContent).forEach(([toolName, toolInfo]) => {
+            if (!toolInfo) return; // Skip if tool info is undefined
+
+            html += `
+                <div class="tool-section mb-6 border-b border-gray-200 pb-4">
+                    <h3 class="text-lg font-semibold text-blue-600 mb-2">${toolInfo.name || toolName}</h3>
+                    <p class="text-gray-700 mb-4">${toolInfo.description || 'No description available'}</p>
+                    
+                    <div class="input-schema bg-gray-50 p-4 rounded-lg">
+                        <h4 class="text-md font-semibold text-gray-700 mb-2">Input Schema</h4>
+                        ${this.renderInputSchema(toolInfo.inputSchema)}
+                    </div>
+                </div>
+            `;
+        });
+
+        html += '</div>';
+        return html;
+    }
+
+    renderInputSchema(schema) {
+        if (!schema || typeof schema !== 'object') {
+            return '<p>No input schema available</p>';
+        }
+
+        // Handle case where schema might be empty or have no properties
+        if (!schema.properties || Object.keys(schema.properties).length === 0) {
+            return '<p>No input properties defined</p>';
+        }
+
+        let html = '<div class="properties-list">';
+
+        try {
+            // Required fields banner if any
+            if (schema.required && Array.isArray(schema.required) && schema.required.length > 0) {
+                html += `
+                    <div class="required-fields mb-3 bg-yellow-50 p-2 rounded">
+                        <span class="text-sm font-medium text-yellow-800">Required fields: ${schema.required.join(', ')}</span>
+                    </div>
+                `;
+            }
+
+            // Render each property
+            Object.entries(schema.properties).forEach(([propName, propDetails]) => {
+                if (!propDetails) return; // Skip if property details are undefined
+
+                const isRequired = schema.required && Array.isArray(schema.required) && schema.required.includes(propName);
+                const type = propDetails.type || 'any';
+
+                html += `
+                    <div class="property-item mb-3 ${isRequired ? 'required' : ''} border-l-2 ${isRequired ? 'border-blue-500' : 'border-gray-300'} pl-3">
+                        <div class="property-header flex items-center gap-2">
+                            <span class="property-name font-medium text-gray-900">${this.escapeHtml(propName)}</span>
+                            <span class="property-type text-sm text-gray-500">(${this.escapeHtml(type)})</span>
+                            ${isRequired ? '<span class="required-badge text-xs bg-blue-100 text-blue-800 px-2 py-0.5 rounded">Required</span>' : ''}
+                        </div>
+                        ${propDetails.description ? `<p class="property-desc text-sm text-gray-600 mt-1">${this.escapeHtml(propDetails.description)}</p>` : ''}
+                        ${propDetails.default !== undefined ? `<p class="property-default text-sm text-gray-500 mt-1">Default: ${this.escapeHtml(JSON.stringify(propDetails.default))}</p>` : ''}
+                    </div>
+                `;
+            });
+
+            html += '</div>';
+            return html;
+        } catch (error) {
+            console.error('Error rendering input schema:', error);
+            return '<p>Error rendering input schema</p>';
+        }
     }
 
     toggle() {
@@ -37,6 +126,18 @@ export class DetailsWidget {
         this.container.querySelector('.server-item-content').classList.add('expanded');
     }
 
+    escapeHtml(unsafe) {
+        if (unsafe === undefined || unsafe === null) {
+            return '';
+        }
+        return String(unsafe)
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#039;");
+    }
+
     collapse() {
         this.widgetElement.classList.remove('expanded');
         this.container.querySelector('.server-item-content').classList.remove('expanded');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imcp",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Node.js SDK for Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli/commands/serve.ts

@@ -8,21 +8,22 @@ export function createServeCommand(): Command {
   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');
         }
 
         await startWebServer(port);
-        
+
         // The server is running, keep the process alive
         process.on('SIGINT', () => {
           console.log('\nShutting down server...');

package/src/core/ConfigurationLoader.ts

@@ -177,25 +177,46 @@ export class ConfigurationLoader {
     /**
      * Loads feed configurations into the MCP configuration
      */
-    static async loadFeedsIntoConfiguration(configuration: MCPConfiguration): Promise<MCPConfiguration> {
+    static async loadFeedsIntoConfiguration(configuration: MCPConfiguration, feedFile?: string): Promise<MCPConfiguration> {
         try {
             await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+            const feeds: Record<string, FeedConfiguration> = {};
+
+            // Load provided feed file if specified
+            if (feedFile) {
+                try {
+                    const content = await fs.readFile(feedFile, 'utf8');
+                    const config = JSON.parse(content) as FeedConfiguration;
+                    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: 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;
+                        // 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);

package/src/core/ConfigurationProvider.ts

@@ -57,7 +57,7 @@ export class ConfigurationProvider {
         }
     }
 
-    async initialize(): Promise<void> {
+    async initialize(feedFile?: string): Promise<void> {
         await this.withLock(async () => {
             const configDir = path.dirname(this.configPath);
             await fs.mkdir(configDir, { recursive: true });
@@ -75,7 +75,7 @@ export class ConfigurationProvider {
                 }
 
                 // Always load feeds and client settings, whether file existed or not
-                await this.loadFeedsIntoConfiguration();
+                await this.loadFeedsIntoConfiguration(feedFile);
                 await this.loadClientMCPSettings();
             } catch (error) {
                 Logger.error('Error during initialization', error);
@@ -340,8 +340,8 @@ export class ConfigurationProvider {
         });
     }
 
-    private async loadFeedsIntoConfiguration(): Promise<void> {
-        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration);
+    private async loadFeedsIntoConfiguration(feedFile?: string): Promise<void> {
+        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile);
         await this.saveConfiguration();
     }
 

package/src/core/MCPManager.ts

@@ -9,8 +9,6 @@ import {
   ServerCategoryListOptions,
   ServerOperationResult,
   ServerUninstallOptions,
-  InstallationStatus,
-  UpdateRequirementOptions
 } from './types.js';
 import path from 'path';
 
@@ -28,9 +26,9 @@ export class MCPManager extends EventEmitter {
     await this.configProvider.syncFeeds();
   }
 
-  async initialize(): Promise<void> {
+  async initialize(feedFile?: string): Promise<void> {
     try {
-      await this.configProvider.initialize();
+      await this.configProvider.initialize(feedFile);
     } catch (error) {
       console.error("Error during MCPManager initialization:", error);
       throw error;