imcp 0.0.14 → 0.0.16

package/dist/core/ConfigurationProvider.d.ts

@@ -24,6 +24,7 @@ export declare class ConfigurationProvider {
     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;

package/dist/core/ConfigurationProvider.js

@@ -216,6 +216,21 @@ export class ConfigurationProvider {
             });
         });
     }
+    async GetServerRequirementStatus(categoryName, serverName) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.feedConfiguration)
+                return [];
+            const serverConfig = category.feedConfiguration.mcpServers.find(s => s.name === serverName);
+            if (!serverConfig?.dependencies?.requirements)
+                return [];
+            const requirementNames = serverConfig.dependencies.requirements.map(r => r.name);
+            return requirementNames
+                .map(name => category?.installationStatus?.requirementsStatus[name])
+                .filter(x => x !== undefined);
+        });
+    }
     async isServerReady(categoryName, serverName, clients) {
         return await this.withLock(async () => {
             // Inline the logic from getServerStatus and getInstallationStatus to avoid nested lock

package/dist/core/InstallationService.js

@@ -118,20 +118,15 @@ export class InstallationService {
                             message: `Updating ${reqToUpdate.name} from ${currentStatus.version || 'unknown'} to ${reqToUpdate.version}`
                         }
                     });
-                    // Create updated requirement config with new version
-                    const updatedReqConfig = {
-                        ...reqConfig,
-                        version: reqToUpdate.version
-                    };
                     // For pip requirements, check if we have a stored pythonEnv
-                    if (updatedReqConfig.type === 'pip' && currentStatus.pythonEnv && !options?.settings?.pythonEnv) {
+                    if (reqConfig.type === 'pip' && currentStatus.pythonEnv && !options?.settings?.pythonEnv) {
                         options = {
                             ...options,
                             settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
                         };
                     }
                     // Update the requirement with options for pip environment
-                    const updatedStatus = await requirementService.updateRequirement(updatedReqConfig, reqToUpdate.version, options);
+                    const updatedStatus = await requirementService.updateRequirement(reqConfig, reqToUpdate.version, options);
                     // Update requirement status
                     await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
                         ...updatedStatus,

package/dist/core/MCPManager.d.ts

@@ -1,17 +1,26 @@
 import { EventEmitter } from 'events';
-import { MCPEvent, MCPEventData, MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions } from './types.js';
+import { MCPEvent, MCPEventData, MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions, FeedConfiguration } from './types.js';
+import { OperationStatus } from './onboard/OnboardStatus.js';
 export declare class MCPManager extends EventEmitter {
     private installationService;
     private configProvider;
+    private feedOnboardService;
     constructor();
     syncFeeds(): Promise<void>;
     initialize(feedFile?: string): Promise<void>;
     listServerCategories(options?: ServerCategoryListOptions): Promise<MCPServerCategory[]>;
-    getFeedConfiguration(categoryName: string): Promise<import("./types.js").FeedConfiguration | undefined>;
+    getFeedConfiguration(categoryName: string): Promise<FeedConfiguration | undefined>;
     getServerMcpConfig(categoryName: string, serverName: string): Promise<import("./types.js").McpConfig | undefined>;
     installServer(categoryName: string, serverName: string, requestOptions?: ServerInstallOptions): Promise<ServerOperationResult>;
     uninstallServer(categoryName: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
     updateRequirement(categoryName: string, serverName: string, requirementName: string, updateVersion: string): Promise<ServerOperationResult>;
+    /**
+     * Onboards a new feed configuration
+     * @param config The feed configuration to onboard
+     */
+    onboardFeed(config: FeedConfiguration): Promise<OperationStatus & {
+        feedConfiguration?: FeedConfiguration;
+    }>;
     emit<E extends MCPEvent>(event: E, data: MCPEventData[E]): boolean;
     on<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this;
     off<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this;

package/dist/core/MCPManager.js

@@ -1,14 +1,18 @@
 import { EventEmitter } from 'events';
 import { ConfigurationProvider } from './ConfigurationProvider.js';
 import { InstallationService } from './InstallationService.js';
-import { MCPEvent } from './types.js';
+import { MCPEvent, } from './types.js';
+import { Logger } from '../utils/logger.js';
+import { FeedOnboardService } from './onboard/FeedOnboardService.js';
 export class MCPManager extends EventEmitter {
     installationService;
     configProvider;
+    feedOnboardService;
     constructor() {
         super();
         this.configProvider = ConfigurationProvider.getInstance();
         this.installationService = new InstallationService();
+        this.feedOnboardService = new FeedOnboardService();
     }
     async syncFeeds() {
         await this.configProvider.syncFeeds();
@@ -149,6 +153,25 @@ export class MCPManager extends EventEmitter {
             };
         }
     }
+    /**
+     * Onboards a new feed configuration
+     * @param config The feed configuration to onboard
+     */
+    async onboardFeed(config) {
+        try {
+            const result = await this.feedOnboardService.onboardFeed(config);
+            // After successful onboarding initiation, sync feeds to get the latest changes
+            // Syncing should ideally happen after the PR is merged, but for now,
+            // syncing here makes the new (pending) category available locally if needed.
+            // Consider if syncFeeds should be conditional based on operation status or handled differently.
+            await this.syncFeeds();
+            return result;
+        }
+        catch (error) {
+            Logger.error('Failed to onboard feed in MCPManager:', error);
+            throw error; // Rethrow or handle by returning a failed OperationStatus
+        }
+    }
     // Type-safe event emitter methods
     emit(event, data) {
         return super.emit(event, data);

package/dist/core/RequirementService.js

@@ -73,7 +73,7 @@ export class RequirementService {
         // Create an updated requirement with the new version
         const updatedRequirement = {
             ...requirement,
-            version: updateVersion
+            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
         };
         // Install the updated version
         return await this.installerFactory.install(updatedRequirement, options);
@@ -110,7 +110,7 @@ export class RequirementService {
         }
         // Validate registry configuration if provided
         if (requirement.registry) {
-            const { githubRelease, artifacts, local } = requirement.registry;
+            const { githubRelease, artifacts } = requirement.registry;
             // Validate GitHub release configuration
             if (githubRelease) {
                 if (!githubRelease.repository) {
@@ -126,12 +126,6 @@ export class RequirementService {
                     throw new Error('Registry URL is required for artifacts registry');
                 }
             }
-            // Validate local registry configuration
-            if (local) {
-                if (!local.localPath) {
-                    throw new Error('Local path is required for local registry');
-                }
-            }
         }
     }
 }

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

@@ -0,0 +1,51 @@
+import { OperationStatus, McpConfig, ServerInstallOptions } from '../../types.js';
+/**
+ * Base class for client installers with shared functionality
+ */
+export declare abstract class BaseClientInstaller {
+    /**
+     * Generate a unique operation ID for tracking installations
+     */
+    protected generateOperationId(): string;
+    /**
+     * Set up installation configuration with environment variables and arguments
+     * Handles Python environment configuration if specified
+     */
+    protected setupInstallConfig(serverConfig: McpConfig, options: ServerInstallOptions): Promise<any>;
+    /**
+     * Resolves and replaces known macro expressions (e.g., ${PYTHON_PACKAGE}, ${NPMPATH}, ${BROWSER_PATH})
+     * in the provided configuration object's 'args' and 'env' properties.
+     * This method directly mutates the finalConfig object.
+     * @param finalConfig The configuration object to modify.
+     * @param options Server installation options which may contain settings like pythonEnv or npmPath.
+     */
+    private _resolveConfigMacros;
+    /**
+     * Handle NPX commands for Windows platform
+     */
+    protected handleWindowsNpx(config: any): Promise<any>;
+    /**
+     * Initialize settings object with client-specific structure
+     * Override in child classes to provide custom initialization
+     */
+    protected initializeSettings(settings: any): void;
+    /**
+     * Handle stdio mode configuration
+     * Override in child classes to provide custom stdio configuration
+     */
+    protected handleStdioMode(settings: any, serverName: string, finalConfig: any): Promise<void>;
+    /**
+     * Handle SSE mode configuration
+     * Override in child classes to provide custom SSE configuration
+     */
+    protected handleSseMode(settings: any, serverName: string, installConfig: any): void;
+    /**
+     * Get the NPM path on Windows
+     */
+    private getNpmPath;
+    /**
+     * Abstract methods 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

@@ -0,0 +1,160 @@
+import { Logger } from '../../../utils/logger.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { MACRO_EXPRESSIONS, MacroResolverFunctions } from '../../../utils/macroExpressionUtils.js';
+const execAsync = promisify(exec);
+/**
+ * Base class for client installers with shared functionality
+ */
+export class BaseClientInstaller {
+    /**
+     * Generate a unique operation ID for tracking installations
+     */
+    generateOperationId() {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Set up installation configuration with environment variables and arguments
+     * Handles Python environment configuration if specified
+     */
+    async setupInstallConfig(serverConfig, options) {
+        const finalConfig = { ...serverConfig.installation };
+        finalConfig.mode = serverConfig.mode;
+        // Handle command line arguments
+        if (options.args && options.args.length > 0) {
+            Logger.debug(`Using args from ServerInstallOptions: ${options.args.join(' ')}`);
+            finalConfig.args = options.args;
+        }
+        // Handle environment variables
+        const baseEnv = finalConfig.env || {};
+        const defaultEnv = {};
+        for (const [key, config] of Object.entries(baseEnv)) {
+            const envConfig = config;
+            if (envConfig.Default) {
+                defaultEnv[key] = envConfig.Default;
+            }
+        }
+        finalConfig.env = { ...defaultEnv, ...(options.env || {}) };
+        // Handle macro expressions
+        await this._resolveConfigMacros(finalConfig, options);
+        Logger.debug(`Final installation config: ${JSON.stringify(finalConfig)}`);
+        return finalConfig;
+    }
+    /**
+     * Resolves and replaces known macro expressions (e.g., ${PYTHON_PACKAGE}, ${NPMPATH}, ${BROWSER_PATH})
+     * in the provided configuration object's 'args' and 'env' properties.
+     * This method directly mutates the finalConfig object.
+     * @param finalConfig The configuration object to modify.
+     * @param options Server installation options which may contain settings like pythonEnv or npmPath.
+     */
+    async _resolveConfigMacros(finalConfig, options) {
+        for (const macro of Object.values(MACRO_EXPRESSIONS)) {
+            const isMacroInArgs = finalConfig.args?.some((arg) => typeof arg === 'string' && arg.includes(macro));
+            const isMacroInEnv = Object.values(finalConfig.env || {}).some(value => typeof value === 'string' && value.includes(macro));
+            if (!isMacroInArgs && !isMacroInEnv) {
+                Logger.debug(`Macro ${macro} not found in args or env, skipping resolution.`);
+                continue;
+            }
+            const resolver = MacroResolverFunctions[macro];
+            if (resolver) {
+                const resolvedValue = await resolver(finalConfig, options);
+                if (resolvedValue !== undefined) {
+                    // Replace in args
+                    if (finalConfig.args) {
+                        const originalArgsString = finalConfig.args.join(' ');
+                        finalConfig.args = finalConfig.args.map((arg) => typeof arg === 'string' && arg.includes(macro)
+                            ? arg.replace(new RegExp(macro.replace(/[${}]/g, '\\$&'), 'g'), resolvedValue)
+                            : arg);
+                        if (finalConfig.args.join(' ') !== originalArgsString) {
+                            Logger.debug(`Args after ${macro} ('${resolvedValue}') replacement: ${finalConfig.args.join(' ')}`);
+                        }
+                    }
+                    // Replace in env
+                    if (finalConfig.env) {
+                        const originalEnvJson = JSON.stringify(finalConfig.env);
+                        for (const key in finalConfig.env) {
+                            if (typeof finalConfig.env[key] === 'string' && finalConfig.env[key].includes(macro)) {
+                                finalConfig.env[key] = finalConfig.env[key].replace(new RegExp(macro.replace(/[${}]/g, '\\$&'), 'g'), resolvedValue);
+                            }
+                        }
+                        if (JSON.stringify(finalConfig.env) !== originalEnvJson) {
+                            Logger.debug(`Env after ${macro} ('${resolvedValue}') replacement: ${JSON.stringify(finalConfig.env)}`);
+                        }
+                    }
+                }
+                else {
+                    Logger.debug(`Could not resolve value for macro: ${macro}. It will not be replaced.`);
+                }
+            }
+        }
+    }
+    /**
+     * Handle NPX commands for Windows platform
+     */
+    async handleWindowsNpx(config) {
+        if (process.platform === 'win32' && config.command === 'npx') {
+            const npmPath = await this.getNpmPath();
+            return {
+                ...config,
+                command: 'cmd',
+                args: ['/c', 'npx', ...config.args],
+                env: {
+                    ...config.env,
+                    'APPDATA': npmPath
+                }
+            };
+        }
+        return config;
+    }
+    /**
+     * Initialize settings object with client-specific structure
+     * Override in child classes to provide custom initialization
+     */
+    initializeSettings(settings) {
+        if (!settings.mcpServers) {
+            settings.mcpServers = {};
+        }
+    }
+    /**
+     * Handle stdio mode configuration
+     * Override in child classes to provide custom stdio configuration
+     */
+    async handleStdioMode(settings, serverName, finalConfig) {
+        // Convert backslashes to forward slashes in args
+        if (finalConfig.args) {
+            finalConfig.args = finalConfig.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
+        }
+        settings.mcpServers[serverName] = {
+            command: finalConfig.command,
+            args: finalConfig.args,
+            env: finalConfig.env,
+            autoApprove: [],
+            disabled: false,
+            alwaysAllow: []
+        };
+    }
+    /**
+     * Handle SSE mode configuration
+     * Override in child classes to provide custom SSE configuration
+     */
+    handleSseMode(settings, serverName, installConfig) {
+        settings.mcpServers[serverName] = {
+            type: 'sse',
+            url: installConfig.url
+        };
+    }
+    /**
+     * Get the NPM path on Windows
+     */
+    async getNpmPath() {
+        try {
+            const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
+            return stdout.trim().replace(/\\npm\.cmd$/, '');
+        }
+        catch (error) {
+            Logger.error('Error getting npm path:', error);
+            return 'C:\\Program Files\\nodejs';
+        }
+    }
+}
+//# sourceMappingURL=BaseClientInstaller.js.map

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

@@ -1,23 +1,30 @@
 import { ServerOperationResult, ServerInstallOptions } from '../../types.js';
+/**
+ * Main client installer class that orchestrates client installation process
+ * Handles requirements checking and delegates to specific client installers
+ */
 export declare class ClientInstaller {
     private categoryName;
     private serverName;
     private clients;
     private configProvider;
-    private operationStatuses;
     constructor(categoryName: string, serverName: string, clients: string[]);
+    /**
+     * Generate a unique operation ID for tracking installations
+     */
     private generateOperationId;
-    private getNpmPath;
     /**
-     * Check if a command is available on the system
-     * @param command The command to check
-     * @returns True if the command is available, false otherwise
+     * Check if server requirements are ready
+     * Waits for requirements to be ready with timeout
+     */
+    private checkRequirements;
+    /**
+     * Install client with requirements checking
      */
-    private isCommandAvailable;
     private installClient;
     private processInstallation;
-    private installClientConfig;
-    private updateClineOrMSRooSettings;
-    private updateGithubCopilotSettings;
+    /**
+     * Install all specified clients
+     */
     install(options: ServerInstallOptions): Promise<ServerOperationResult>;
 }