imcp 0.0.17 → 0.0.19

package/dist/cli/commands/serve.js

@@ -6,12 +6,13 @@ export function createServeCommand() {
         .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')
+        .option('-s, --schemas-directory <path>', 'Path to a directory containing adhoc schema files')
         .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(options.feedFile);
+            await mcpManager.initialize(options.feedFile, options.schemasDirectory);
             const port = parseInt(options.port, 10);
             if (isNaN(port) || port < 1 || port > 65535) {
                 throw new Error('Invalid port number');

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

@@ -3,6 +3,7 @@ import { OperationStatus, McpConfig, ServerInstallOptions } from '../../metadata
  * Base class for client installers with shared functionality
  */
 export declare abstract class BaseClientInstaller {
+    protected abstract readonly clientName: string;
     /**
      * Generate a unique operation ID for tracking installations
      */
@@ -44,8 +45,30 @@ export declare abstract class BaseClientInstaller {
      */
     private getNpmPath;
     /**
-     * Abstract methods that must be implemented by client-specific installers
+     * Checks if VS Code or VS Code Insiders is installed and installs the client extension.
+     * @param operationId The operation ID for tracking.
+     * @returns An OperationStatus object if checks fail or installation fails, otherwise undefined.
+     */
+    protected checkVSCodeAndInstallExtension(operationId: string): Promise<OperationStatus | undefined>;
+    /**
+     * Update VS Code settings for both VS Code and VS Code Insiders if installed
+     * @param serverName The name of the server to configure
+     * @param installConfig The installation configuration
+     * @returns Array of results indicating success/failure for each VS Code variant
+     */
+    protected updateVSCodeSettings(serverName: string, installConfig: any): Promise<Array<{
+        success: boolean;
+        path: string;
+        error?: string;
+    }>>;
+    /**
+     * Install the client
+     * @param serverConfig Server configuration
+     * @param options Installation options including environment variables and arguments
+     */
+    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    /**
+     * Abstract method that must be implemented by client-specific installers
      */
-    abstract install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
     abstract setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void>;
 }

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

@@ -1,6 +1,9 @@
 import { Logger } from '../../../utils/logger.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 import { MACRO_EXPRESSIONS, MacroResolverFunctions } from '../../../utils/macroExpressionUtils.js';
 const execAsync = promisify(exec);
 /**
@@ -156,5 +159,123 @@ export class BaseClientInstaller {
             return 'C:\\Program Files\\nodejs';
         }
     }
+    /**
+     * Checks if VS Code or VS Code Insiders is installed and installs the client extension.
+     * @param operationId The operation ID for tracking.
+     * @returns An OperationStatus object if checks fail or installation fails, otherwise undefined.
+     */
+    async checkVSCodeAndInstallExtension(operationId) {
+        // Check if VS Code or VS Code Insiders is installed
+        const isVSCodeInstalled = await isCommandAvailable('code');
+        const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+        if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: 'Failed to install as neither VS Code nor VS Code Insiders are installed on this system. Please run `code` or `code-insiders` to make sure they are installed. Relaunch imcp after installation.',
+                operationId
+            };
+        }
+        // Install extension
+        const extensionResult = await ExtensionInstaller.installExtension(this.clientName);
+        if (!extensionResult) {
+            Logger.debug(`Failed to install ${this.clientName} extension`);
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Failed to install ${this.clientName} extension`,
+                operationId
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Update VS Code settings for both VS Code and VS Code Insiders if installed
+     * @param serverName The name of the server to configure
+     * @param installConfig The installation configuration
+     * @returns Array of results indicating success/failure for each VS Code variant
+     */
+    async updateVSCodeSettings(serverName, installConfig) {
+        const results = [];
+        const isVSCodeInstalled = await isCommandAvailable('code');
+        const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+        // Update settings for VS Code if installed
+        if (isVSCodeInstalled) {
+            try {
+                const settingPath = SUPPORTED_CLIENTS[this.clientName].codeSettingPath;
+                await this.setupClientSettings(settingPath, serverName, installConfig);
+                results.push({ success: true, path: settingPath });
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    path: SUPPORTED_CLIENTS[this.clientName].codeSettingPath,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        // Update settings for VS Code Insiders if installed
+        if (isVSCodeInsidersInstalled) {
+            try {
+                const settingPath = SUPPORTED_CLIENTS[this.clientName].codeInsiderSettingPath;
+                await this.setupClientSettings(settingPath, serverName, installConfig);
+                results.push({ success: true, path: settingPath });
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    path: SUPPORTED_CLIENTS[this.clientName].codeInsiderSettingPath,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Install the client
+     * @param serverConfig Server configuration
+     * @param options Installation options including environment variables and arguments
+     */
+    async install(serverConfig, options) {
+        const operationId = this.generateOperationId();
+        try {
+            const vsCodeCheckResult = await this.checkVSCodeAndInstallExtension(operationId);
+            if (vsCodeCheckResult) {
+                return vsCodeCheckResult;
+            }
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+            if (serverConfig.mode) {
+                installConfig.mode = serverConfig.mode;
+            }
+            // Update VS Code settings
+            const results = await this.updateVSCodeSettings(serverConfig.name, installConfig);
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess
+                    ? `Successfully installed ${this.clientName} client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install ${this.clientName} client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing ${this.clientName} client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
 }
 //# sourceMappingURL=BaseClientInstaller.js.map

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

@@ -1,15 +1,10 @@
 import { BaseClientInstaller } from './BaseClientInstaller.js';
-import { ServerInstallOptions, OperationStatus, McpConfig } from '../../metadatas/types.js';
 /**
  * Cline client installer implementation
  * Handles installation of Cline client including extension installation and settings configuration
  */
 export declare class ClineInstaller extends BaseClientInstaller {
-    /**
-     * Install Cline client
-     * @param options Installation options including environment variables and arguments
-     */
-    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    protected readonly clientName: string;
     /**
      * Set up Cline client settings
      * Updates VS Code settings with MCP server configuration

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

@@ -1,104 +1,11 @@
 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 '../../metadatas/constants.js';
-import { isCommandAvailable } from '../../../utils/osUtils.js';
 /**
  * Cline client installer implementation
  * Handles installation of Cline client including extension installation and settings configuration
  */
 export class ClineInstaller extends BaseClientInstaller {
-    /**
-     * Install Cline client
-     * @param options Installation options including environment variables and arguments
-     */
-    async install(serverConfig, options) {
-        const operationId = this.generateOperationId();
-        try {
-            // Check if VS Code or VS Code Insiders is installed
-            const isVSCodeInstalled = await isCommandAvailable('code');
-            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
-            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
-                return {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
-                    operationId
-                };
-            }
-            // Install extension
-            const extensionResult = await ExtensionInstaller.installExtension('Cline');
-            if (!extensionResult) {
-                Logger.debug('Failed to install Cline extension');
-                return {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: 'Failed to install Cline extension',
-                    operationId
-                };
-            }
-            const installConfig = await this.setupInstallConfig(serverConfig, options);
-            // Track success for both VS Code variants
-            const results = [];
-            // Update settings for VS Code if installed
-            if (isVSCodeInstalled) {
-                try {
-                    const settingPath = SUPPORTED_CLIENTS['Cline'].codeSettingPath;
-                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
-                    results.push({ success: true, path: settingPath });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        path: SUPPORTED_CLIENTS['Cline'].codeSettingPath,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Update settings for VS Code Insiders if installed
-            if (isVSCodeInsidersInstalled) {
-                try {
-                    const settingPath = SUPPORTED_CLIENTS['Cline'].codeInsiderSettingPath;
-                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
-                    results.push({ success: true, path: settingPath });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        path: SUPPORTED_CLIENTS['Cline'].codeInsiderSettingPath,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Determine overall success
-            const anySuccess = results.some(r => r.success);
-            const successPaths = results.filter(r => r.success).map(r => r.path);
-            const errors = results.filter(r => !r.success).map(r => r.error);
-            return {
-                status: anySuccess ? 'completed' : 'failed',
-                type: 'install',
-                target: 'server',
-                message: anySuccess
-                    ? `Successfully installed Cline client. Updated settings in: ${successPaths.join(', ')}`
-                    : `Failed to install Cline client. Errors: ${errors.join('; ')}`,
-                operationId,
-                error: anySuccess ? undefined : errors.join('; ')
-            };
-        }
-        catch (error) {
-            return {
-                status: 'failed',
-                type: 'install',
-                target: 'server',
-                message: `Unexpected error installing Cline client: ${error instanceof Error ? error.message : String(error)}`,
-                operationId,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
+    clientName = 'Cline';
     /**
      * Set up Cline client settings
      * Updates VS Code settings with MCP server configuration

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

@@ -1,15 +1,10 @@
 import { BaseClientInstaller } from './BaseClientInstaller.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
  */
 export declare class GithubCopilotInstaller extends BaseClientInstaller {
-    /**
-     * Install Github Copilot client
-     * @param options Installation options including environment variables and arguments
-     */
-    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    protected readonly clientName: string;
     /**
      * Initialize settings with GithubCopilot-specific structure
      * Overrides base method to provide custom initialization

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

@@ -1,104 +1,11 @@
 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 '../../metadatas/constants.js';
-import { isCommandAvailable } from '../../../utils/osUtils.js';
 /**
  * Github Copilot client installer implementation
  * Handles installation of Github Copilot client including extension installation and settings configuration
  */
 export class GithubCopilotInstaller extends BaseClientInstaller {
-    /**
-     * Install Github Copilot client
-     * @param options Installation options including environment variables and arguments
-     */
-    async install(serverConfig, options) {
-        const operationId = this.generateOperationId();
-        try {
-            // Check if VS Code or VS Code Insiders is installed
-            const isVSCodeInstalled = await isCommandAvailable('code');
-            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
-            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
-                return {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
-                    operationId
-                };
-            }
-            // Install extension
-            const extensionResult = await ExtensionInstaller.installExtension('GithubCopilot');
-            if (!extensionResult) {
-                Logger.debug('Failed to install Github Copilot extension');
-                return {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: 'Failed to install Github Copilot extension',
-                    operationId
-                };
-            }
-            const installConfig = await this.setupInstallConfig(serverConfig, options);
-            // Track success for both VS Code variants
-            const results = [];
-            // Update settings for VS Code if installed
-            if (isVSCodeInstalled) {
-                try {
-                    const settingPath = SUPPORTED_CLIENTS['GithubCopilot'].codeSettingPath;
-                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
-                    results.push({ success: true, path: settingPath });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        path: SUPPORTED_CLIENTS['GithubCopilot'].codeSettingPath,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Update settings for VS Code Insiders if installed
-            if (isVSCodeInsidersInstalled) {
-                try {
-                    const settingPath = SUPPORTED_CLIENTS['GithubCopilot'].codeInsiderSettingPath;
-                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
-                    results.push({ success: true, path: settingPath });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        path: SUPPORTED_CLIENTS['GithubCopilot'].codeInsiderSettingPath,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Determine overall success
-            const anySuccess = results.some(r => r.success);
-            const successPaths = results.filter(r => r.success).map(r => r.path);
-            const errors = results.filter(r => !r.success).map(r => r.error);
-            return {
-                status: anySuccess ? 'completed' : 'failed',
-                type: 'install',
-                target: 'server',
-                message: anySuccess
-                    ? `Successfully installed Github Copilot client. Updated settings in: ${successPaths.join(', ')}`
-                    : `Failed to install Github Copilot client. Errors: ${errors.join('; ')}`,
-                operationId,
-                error: anySuccess ? undefined : errors.join('; ')
-            };
-        }
-        catch (error) {
-            return {
-                status: 'failed',
-                type: 'install',
-                target: 'server',
-                message: `Unexpected error installing Github Copilot client: ${error instanceof Error ? error.message : String(error)}`,
-                operationId,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
+    clientName = 'GithubCopilot';
     /**
      * Initialize settings with GithubCopilot-specific structure
      * Overrides base method to provide custom initialization

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

@@ -1,13 +1,9 @@
 import { BaseClientInstaller } from './BaseClientInstaller.js';
-import { ServerInstallOptions, OperationStatus, McpConfig } from '../../metadatas/types.js';
 /**
  * MSRooCode client installer implementation
  */
 export declare class MSRooCodeInstaller extends BaseClientInstaller {
-    /**
-     * Install MSRooCode client
-     */
-    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    protected readonly clientName: string;
     /**
      * Set up MSRooCode client settings
      */

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

@@ -1,103 +1,10 @@
 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 '../../metadatas/constants.js';
-import { isCommandAvailable } from '../../../utils/osUtils.js';
 /**
  * MSRooCode client installer implementation
  */
 export class MSRooCodeInstaller extends BaseClientInstaller {
-    /**
-     * Install MSRooCode client
-     */
-    async install(serverConfig, options) {
-        const operationId = this.generateOperationId();
-        try {
-            // Check if VS Code or VS Code Insiders is installed
-            const isVSCodeInstalled = await isCommandAvailable('code');
-            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
-            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
-                return {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
-                    operationId
-                };
-            }
-            // Install extension
-            const extensionResult = await ExtensionInstaller.installExtension('MSRooCode');
-            if (!extensionResult) {
-                Logger.debug('Failed to install MSRooCode extension');
-                return {
-                    status: 'failed',
-                    type: 'install',
-                    target: 'server',
-                    message: 'Failed to install MSRooCode extension',
-                    operationId
-                };
-            }
-            const installConfig = await this.setupInstallConfig(serverConfig, options);
-            installConfig.mode = serverConfig.mode;
-            // Track success for both VS Code variants
-            const results = [];
-            // Update settings for VS Code if installed
-            if (isVSCodeInstalled) {
-                try {
-                    const settingPath = SUPPORTED_CLIENTS['MSRooCode'].codeSettingPath;
-                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
-                    results.push({ success: true, path: settingPath });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        path: SUPPORTED_CLIENTS['MSRooCode'].codeSettingPath,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Update settings for VS Code Insiders if installed
-            if (isVSCodeInsidersInstalled) {
-                try {
-                    const settingPath = SUPPORTED_CLIENTS['MSRooCode'].codeInsiderSettingPath;
-                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
-                    results.push({ success: true, path: settingPath });
-                }
-                catch (error) {
-                    results.push({
-                        success: false,
-                        path: SUPPORTED_CLIENTS['MSRooCode'].codeInsiderSettingPath,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Determine overall success
-            const anySuccess = results.some(r => r.success);
-            const successPaths = results.filter(r => r.success).map(r => r.path);
-            const errors = results.filter(r => !r.success).map(r => r.error);
-            return {
-                status: anySuccess ? 'completed' : 'failed',
-                type: 'install',
-                target: 'server',
-                message: anySuccess
-                    ? `Successfully installed MSRooCode client. Updated settings in: ${successPaths.join(', ')}`
-                    : `Failed to install MSRooCode client. Errors: ${errors.join('; ')}`,
-                operationId,
-                error: anySuccess ? undefined : errors.join('; ')
-            };
-        }
-        catch (error) {
-            return {
-                status: 'failed',
-                type: 'install',
-                target: 'server',
-                message: `Unexpected error installing MSRooCode client: ${error instanceof Error ? error.message : String(error)}`,
-                operationId,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
+    clientName = 'MSRooCode';
     /**
      * Set up MSRooCode client settings
      */

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

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

package/dist/core/loaders/ConfigurationLoader.js

@@ -140,7 +140,7 @@ export class ConfigurationLoader {
     /**
      * Loads feed configurations into the MCP configuration
      */
-    static async loadFeedsIntoConfiguration(configuration, feedFile) {
+    static async loadFeedsIntoConfiguration(configuration, feedFile, settings) {
         try {
             await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
             const feeds = {};
@@ -148,10 +148,31 @@ export class ConfigurationLoader {
             if (feedFile) {
                 try {
                     const content = await fs.readFile(feedFile, 'utf8');
-                    const config = JSON.parse(content);
+                    let config = JSON.parse(content);
                     if (config && config.name) {
+                        // Update systemTags if feedFile is provided
+                        if (!config.systemTags) {
+                            config.systemTags = {};
+                        }
+                        config.systemTags['adhoc'] = 'true';
+                        // Update PullRequest if prLink is provided in settings
+                        if (settings?.prLink) {
+                            config.PullRequest = settings.prLink;
+                        }
+                        // Update mcpServers systemTags if adhocServers are provided in settings
+                        if (settings?.adhocServers && settings.adhocServers.length > 0 && config.mcpServers) {
+                            config.mcpServers = config.mcpServers.map(server => {
+                                if (settings.adhocServers.includes(server.name)) {
+                                    if (!server.systemTags) {
+                                        server.systemTags = {};
+                                    }
+                                    server.systemTags['adhoc'] = 'true';
+                                }
+                                return server;
+                            });
+                        }
                         feeds[config.name] = config;
-                        console.log(`Loaded feed configuration from provided file: ${feedFile}`);
+                        console.log(`Loaded and processed feed configuration from provided file: ${feedFile}`);
                     }
                 }
                 catch (error) {

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

@@ -8,7 +8,10 @@ export declare class ConfigurationProvider {
     private constructor();
     static getInstance(): ConfigurationProvider;
     private withLock;
-    initialize(feedFile?: string): Promise<void>;
+    initialize(feedFile?: string, settings?: {
+        prLink?: string;
+        adhocServers?: string[];
+    }): Promise<void>;
     private saveConfiguration;
     getServerCategories(): Promise<MCPServerCategory[]>;
     getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;