imcp 0.1.7 → 0.1.8-dev

package/dist/core/InstallationService.js

@@ -1,350 +0,0 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { exec } from 'child_process';
-import util from 'util';
-import { createInstallerFactory } from './installers/index.js';
-import { SUPPORTED_CLIENTS } from './constants.js';
-import { ClientInstaller } from './installers/clients/ClientInstaller.js';
-import { ConfigurationProvider } from './ConfigurationProvider.js';
-import { Logger } from '../utils/logger.js';
-const execPromise = util.promisify(exec);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-/**
- * Handles the actual installation process for an MCP server.
- */
-export class InstallationService {
-    activeInstallations = new Map();
-    installerFactory;
-    constructor() {
-        this.installerFactory = createInstallerFactory();
-    }
-    generateOperationId() {
-        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    /**
-     * Installs a server based on the provided options and feed configuration.
-     * @param serverName The name of the server to install.
-     * @param options The installation options.
-     * @returns A result object indicating success or failure.
-     */
-    async install(categoryName, serverName, options) {
-        const configProvider = ConfigurationProvider.getInstance();
-        const clients = options.targetClients || Object.keys(SUPPORTED_CLIENTS);
-        // Process updates for requirements if specified in options
-        // Fire off requirement updates in the background without awaiting completion
-        if (options.requirements && options.requirements.length > 0) {
-            // Start the process but don't await it - it will run in the background
-            this.processRequirementUpdates(categoryName, serverName, options)
-                .catch(error => {
-                console.error(`Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`);
-            });
-        }
-        // Check if server is already ready
-        const isReady = await configProvider.isServerReady(categoryName, serverName, clients);
-        if (isReady) {
-            return {
-                success: true,
-                message: 'Server and clients are already installed and ready',
-                status: [{
-                        status: 'completed',
-                        type: 'install',
-                        target: 'server',
-                        message: 'Server and clients are already installed and ready'
-                    }]
-            };
-        }
-        // Create new ClientInstaller instance for handling installation
-        const clientInstaller = new ClientInstaller(categoryName, serverName, clients);
-        const requirementsResult = await this.checkAndInstallRequirements(categoryName, serverName, options);
-        if (requirementsResult) {
-            return requirementsResult;
-        }
-        // Process client installation regardless of requirements state
-        // Each client installer will check requirements before actual installation
-        return await clientInstaller.install(options);
-    }
-    /**
-     * Process requirement updates specified in serverInstallOptions
-     * All updates are processed in parallel for maximum efficiency
-     * @param categoryName The category name
-     * @param serverName The server name
-     * @param requirements The requirements to update
-     */
-    async processRequirementUpdates(categoryName, serverName, options) {
-        // Use UpdateCheckTracker to prevent concurrent updates
-        const updateCheckTracker = await import('../utils/UpdateCheckTracker.js').then(m => m.updateCheckTracker);
-        const operationKey = `requirement-updates-${categoryName}-${serverName}`;
-        // Check if there's already an update operation in progress for this server
-        const canProceed = await updateCheckTracker.startOperation(operationKey);
-        if (!canProceed) {
-            console.log(`Requirement updates for ${categoryName}/${serverName} already in progress, skipping`);
-            return;
-        }
-        try {
-            const configProvider = ConfigurationProvider.getInstance();
-            const feedConfig = await configProvider.getFeedConfiguration(categoryName);
-            if (!feedConfig) {
-                console.error(`Feed configuration not found for category: ${categoryName}`);
-                return;
-            }
-            // Import the RequirementService
-            const { requirementService } = await import('./RequirementService.js');
-            // Create an array of promises to update all requirements in parallel
-            const updatePromises = options.requirements?.map(async (reqToUpdate) => {
-                try {
-                    // Find the full requirement config
-                    const reqConfig = feedConfig.requirements?.find((r) => r.name === reqToUpdate.name);
-                    if (!reqConfig) {
-                        console.error(`Requirement configuration not found for: ${reqToUpdate.name}`);
-                        return;
-                    }
-                    // Get current status
-                    const currentStatus = await configProvider.getRequirementStatus(categoryName, reqToUpdate.name);
-                    if (!currentStatus) {
-                        console.error(`No current status found for requirement: ${reqToUpdate.name}`);
-                        return;
-                    }
-                    // Update requirement status to indicate update in progress
-                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-                        ...currentStatus,
-                        name: reqToUpdate.name,
-                        type: currentStatus.type || 'unknown',
-                        installed: currentStatus.installed || false,
-                        inProgress: true,
-                        operationStatus: {
-                            status: 'in-progress',
-                            type: 'update',
-                            target: 'requirement',
-                            message: `Updating ${reqToUpdate.name} from ${currentStatus.version || 'unknown'} to ${reqToUpdate.version}`
-                        }
-                    });
-                    // For pip requirements, check if we have a stored 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(reqConfig, reqToUpdate.version, options);
-                    // Update requirement status
-                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-                        ...updatedStatus,
-                        name: reqToUpdate.name,
-                        type: updatedStatus.type || currentStatus.type || 'unknown',
-                        installed: updatedStatus.installed,
-                        inProgress: false,
-                        operationStatus: {
-                            status: updatedStatus.installed ? 'completed' : 'failed',
-                            type: 'update',
-                            target: 'requirement',
-                            message: updatedStatus.installed
-                                ? `Successfully updated ${reqToUpdate.name} to version ${reqToUpdate.version}`
-                                : `Failed to update ${reqToUpdate.name} to version ${reqToUpdate.version}`
-                        },
-                        availableUpdate: updatedStatus.installed ? undefined : currentStatus.availableUpdate
-                    });
-                    console.log(`Requirement ${reqToUpdate.name} updated to version ${reqToUpdate.version}`);
-                }
-                catch (error) {
-                    console.error(`Error updating requirement ${reqToUpdate.name}:`, error);
-                    // Update status to indicate failure
-                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
-                        name: reqToUpdate.name,
-                        type: 'unknown',
-                        installed: false,
-                        inProgress: false,
-                        error: error instanceof Error ? error.message : String(error),
-                        operationStatus: {
-                            status: 'failed',
-                            type: 'update',
-                            target: 'requirement',
-                            message: `Error updating requirement: ${error instanceof Error ? error.message : String(error)}`
-                        }
-                    });
-                }
-            });
-            // Wait for all updates to complete in parallel if there are any
-            if (updatePromises) {
-                await Promise.all(updatePromises);
-            }
-        }
-        finally {
-            // Always release the lock when done, even if there was an error
-            await updateCheckTracker.endOperation(operationKey);
-        }
-    }
-    /**
-     * 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
-     */
-    async checkAndInstallRequirements(categoryName, serverName, options) {
-        const configProvider = ConfigurationProvider.getInstance();
-        // Get feed configuration to get requirements
-        const feedConfig = await configProvider.getFeedConfiguration(categoryName);
-        if (!feedConfig) {
-            return {
-                success: false,
-                message: 'Feed configuration not found',
-                status: [{
-                        status: 'failed',
-                        type: 'install',
-                        target: 'server',
-                        message: 'Feed configuration not found'
-                    }]
-            };
-        }
-        // Find server config and verify requirements
-        const serverConfig = feedConfig.mcpServers.find((s) => s.name === serverName);
-        if (!serverConfig?.dependencies?.requirements) {
-            Logger.debug(`No requirements for ${serverName}`);
-            return null;
-        }
-        // Check all requirements installation status
-        const requirementStatuses = await Promise.all(serverConfig.dependencies.requirements.map(async (req) => {
-            const reqConfig = feedConfig.requirements?.find((r) => r.name === req.name) || {
-                name: req.name,
-                version: req.version,
-                type: 'npm'
-            };
-            return await this.installerFactory.checkInstallation(reqConfig, options);
-        }));
-        // If all requirements are installed and ready, no need to proceed with installation
-        if (requirementStatuses.every(status => status.installed)) {
-            // Check if requirements are ready via ConfigurationProvider
-            const requirementsReady = await configProvider.isRequirementsReady(categoryName, serverName);
-            // Update requirement status if not ready
-            if (!requirementsReady) {
-                for (const status of requirementStatuses) {
-                    await configProvider.updateRequirementStatus(categoryName, status.name, status);
-                }
-            }
-            return null;
-        }
-        // Sort requirements by order for installation
-        const sortedRequirements = [...serverConfig.dependencies.requirements].sort((a, b) => {
-            const orderA = a.order ?? Infinity;
-            const orderB = b.order ?? Infinity;
-            return orderA - orderB;
-        });
-        // Start requirements installation in background
-        this.installRequirementsInBackground(categoryName, sortedRequirements, options)
-            .catch(error => {
-            Logger.error(`Error in background requirement installations: ${error instanceof Error ? error.message : String(error)}`);
-        });
-        // Return immediately while installation continues in background
-        return null;
-    }
-    /**
-     * Installs requirements in background without blocking the main thread
-     * Requirements with the same order are installed in parallel
-     */
-    async installRequirementsInBackground(categoryName, sortedRequirements, options) {
-        const configProvider = ConfigurationProvider.getInstance();
-        const requirementGroups = sortedRequirements.reduce((groups, req) => {
-            const order = req.order ?? Infinity;
-            if (!groups[order]) {
-                groups[order] = [];
-            }
-            groups[order].push(req);
-            return groups;
-        }, {});
-        // Process each group in sequence, but requirements within group in parallel
-        const orderKeys = Object.keys(requirementGroups).map(Number).sort((a, b) => a - b);
-        for (const order of orderKeys) {
-            const group = requirementGroups[order];
-            await Promise.all(group.map(async (requirement) => {
-                try {
-                    const feeds = await configProvider.getFeedConfiguration(categoryName);
-                    const requirementConfig = feeds?.requirements?.find((r) => r.name === requirement.name) || {
-                        name: requirement.name,
-                        version: requirement.version,
-                        type: 'npm'
-                    };
-                    // For pip requirements, check if we need to use stored pythonEnv
-                    const currentStatus = await configProvider.getRequirementStatus(categoryName, requirement.name);
-                    if (requirementConfig.type === 'pip' && currentStatus?.pythonEnv && !options?.settings?.pythonEnv) {
-                        options = {
-                            ...options,
-                            settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
-                        };
-                    }
-                    const installer = this.installerFactory.getInstaller(requirementConfig);
-                    if (!installer) {
-                        await this.updateRequirementFailureStatus(categoryName, requirement.name, requirementConfig.type, `No installer found for requirement type: ${requirementConfig.type}`);
-                        return;
-                    }
-                    const operationId = this.generateOperationId();
-                    await this.updateRequirementProgressStatus(categoryName, requirement.name, requirementConfig.type, operationId);
-                    const installStatus = await installer.install(requirementConfig, options);
-                    await this.updateRequirementCompletionStatus(categoryName, requirement.name, installStatus, operationId);
-                }
-                catch (error) {
-                    await this.updateRequirementFailureStatus(categoryName, requirement.name, 'unknown', error instanceof Error ? error.message : String(error));
-                }
-            }));
-        }
-    }
-    /**
-     * Helper to update requirement status for failure case
-     */
-    async updateRequirementFailureStatus(categoryName, requirementName, requirementType, errorMessage) {
-        const configProvider = ConfigurationProvider.getInstance();
-        await configProvider.updateRequirementStatus(categoryName, requirementName, {
-            name: requirementName,
-            type: requirementType,
-            installed: false,
-            error: errorMessage,
-            operationStatus: {
-                status: 'failed',
-                type: 'install',
-                target: 'requirement',
-                message: `Error installing requirement: ${errorMessage}`,
-                operationId: this.generateOperationId()
-            }
-        });
-    }
-    /**
-     * Helper to update requirement status for in-progress case
-     */
-    async updateRequirementProgressStatus(categoryName, requirementName, requirementType, operationId) {
-        const configProvider = ConfigurationProvider.getInstance();
-        await configProvider.updateRequirementStatus(categoryName, requirementName, {
-            name: requirementName,
-            type: requirementType,
-            installed: false,
-            inProgress: true,
-            operationStatus: {
-                status: 'in-progress',
-                type: 'install',
-                target: 'requirement',
-                message: `Installing requirement: ${requirementName}`,
-                operationId
-            }
-        });
-    }
-    /**
-     * Helper to update requirement status for completion case
-     */
-    async updateRequirementCompletionStatus(categoryName, requirementName, installStatus, operationId) {
-        const configProvider = ConfigurationProvider.getInstance();
-        await configProvider.updateRequirementStatus(categoryName, requirementName, {
-            ...installStatus,
-            operationStatus: {
-                status: installStatus.installed ? 'completed' : 'failed',
-                type: 'install',
-                target: 'requirement',
-                message: installStatus.installed
-                    ? `Requirement ${requirementName} installed successfully`
-                    : `Failed to install ${requirementName}`,
-                operationId
-            }
-        });
-    }
-}
-// Export a singleton instance (optional)
-// export const installationService = new InstallationService();
-//# sourceMappingURL=InstallationService.js.map

package/dist/core/MCPManager.d.ts

@@ -1,28 +0,0 @@
-import { EventEmitter } from 'events';
-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<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;
-}
-export declare const mcpManager: MCPManager;

package/dist/core/MCPManager.js

@@ -1,188 +0,0 @@
-import { EventEmitter } from 'events';
-import { ConfigurationProvider } from './ConfigurationProvider.js';
-import { InstallationService } from './InstallationService.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();
-    }
-    async initialize(feedFile) {
-        try {
-            await this.configProvider.initialize(feedFile);
-        }
-        catch (error) {
-            console.error("Error during MCPManager initialization:", error);
-            throw error;
-        }
-    }
-    async listServerCategories(options = {}) {
-        const { local = true } = options;
-        if (local) {
-            return await this.configProvider.getServerCategories();
-        }
-        return [];
-    }
-    async getFeedConfiguration(categoryName) {
-        return this.configProvider.getFeedConfiguration(categoryName);
-    }
-    async getServerMcpConfig(categoryName, serverName) {
-        return this.configProvider.getServerMcpConfig(categoryName, serverName);
-    }
-    async installServer(categoryName, serverName, requestOptions = {}) {
-        try {
-            const server = await this.configProvider.getServerCategory(categoryName);
-            if (!server) {
-                return {
-                    success: false,
-                    message: `Server category ${categoryName} is not onboarded`,
-                };
-            }
-            const installResult = await this.installationService.install(categoryName, serverName, requestOptions);
-            if (!installResult.success) {
-                return installResult;
-            }
-            this.emit(MCPEvent.SERVER_INSTALLED, { server });
-            return installResult;
-        }
-        catch (error) {
-            console.error(`Unexpected error during installServer for ${serverName}:`, error);
-            return {
-                success: false,
-                message: `Failed to install ${serverName}: ${error instanceof Error ? error.message : String(error)}`,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-    }
-    async uninstallServer(categoryName, serverName, options = {}) {
-        try {
-            const serverCategory = await this.configProvider.getServerCategory(categoryName);
-            if (!serverCategory) {
-                return {
-                    success: false,
-                    message: `Server category ${categoryName} is not onboarded`,
-                };
-            }
-            const { targets = [], removeData = false } = options;
-            // Clear installation status for specified targets
-            const currentStatus = serverCategory.installationStatus || {
-                requirementsStatus: {},
-                serversStatus: {},
-                lastUpdated: new Date().toISOString()
-            };
-            const serversStatus = currentStatus.serversStatus || {};
-            const serverStatus = serversStatus[serverName] || { installedStatus: {}, name: serverName };
-            // Only reset installedStatus for specified targets
-            for (const target of targets) {
-                if (serverStatus.installedStatus) {
-                    delete serverStatus.installedStatus[target];
-                }
-            }
-            if (removeData) {
-                for (const target of targets) {
-                    await this.configProvider.removeServerFromClientMCPSettings(serverName, target);
-                }
-            }
-            // Update server status
-            serversStatus[serverName] = serverStatus;
-            // Update status keeping requirements
-            await this.configProvider.updateInstallationStatus(categoryName, currentStatus.requirementsStatus || {}, serversStatus);
-            this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName, targets });
-            return {
-                success: true,
-                message: `Successfully uninstalled ${serverName} from ${targets.join(', ')}`,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: `Failed to uninstall ${serverName}`,
-                error: error,
-            };
-        }
-    }
-    async updateRequirement(categoryName, serverName, requirementName, updateVersion) {
-        try {
-            const { requirementService } = await import('./RequirementService.js');
-            const serverCategory = await this.configProvider.getServerCategory(categoryName);
-            if (!serverCategory) {
-                return {
-                    success: false,
-                    message: `Server category ${categoryName} is not onboarded`,
-                };
-            }
-            if (!serverCategory.feedConfiguration) {
-                return {
-                    success: false,
-                    message: `Server category ${categoryName} has no feed configuration`,
-                };
-            }
-            // Find the requirement
-            const requirement = serverCategory.feedConfiguration.requirements.find(r => r.name === requirementName);
-            if (!requirement) {
-                return {
-                    success: false,
-                    message: `Requirement ${requirementName} not found in category ${categoryName}`,
-                };
-            }
-            // Update the requirement using requirementService
-            const updatedStatus = await requirementService.updateRequirement(requirement, updateVersion);
-            // Update the status in configuration
-            await this.configProvider.updateRequirementStatus(categoryName, requirementName, updatedStatus);
-            return {
-                success: true,
-                message: `Successfully updated ${requirementName} to version ${updateVersion}`,
-            };
-        }
-        catch (error) {
-            console.error(`Error updating requirement ${requirementName}:`, error);
-            return {
-                success: false,
-                message: `Failed to update ${requirementName}: ${error instanceof Error ? error.message : String(error)}`,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-    }
-    /**
-     * 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);
-    }
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    off(event, listener) {
-        return super.off(event, listener);
-    }
-}
-// Export a singleton instance
-export const mcpManager = new MCPManager();
-//# sourceMappingURL=MCPManager.js.map

package/dist/core/RequirementService.d.ts

@@ -1,40 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from './types.js';
-/**
- * Service responsible for managing requirements installation and status
- */
-export declare class RequirementService {
-    private static instance;
-    private installerFactory;
-    private constructor();
-    /**
-     * Get the singleton instance of RequirementService
-     * @returns The RequirementService instance
-     */
-    static getInstance(): RequirementService;
-    /**
-     * Check the installation status of a requirement
-     * @param requirement The requirement to check
-     * @returns The installation status
-     */
-    checkRequirementStatus(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    /**
-     * Check if updates are available for a requirement
-     * @param requirement The requirement to check for updates
-     * @returns Updated status with available updates information
-     */
-    checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
-    /**
-     * Update a requirement to a new version
-     * @param requirement The requirement configuration
-     * @param updateVersion The version to update to
-     * @returns The updated requirement status
-     */
-    updateRequirement(requirement: RequirementConfig, updateVersion: string, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    /**
-     * Validate a requirement configuration
-     * @param requirement The requirement to validate
-     * @throws Error if the requirement is invalid
-     */
-    private validateRequirement;
-}
-export declare const requirementService: RequirementService;