imcp 0.0.1

package/dist/core/InstallationService.js

@@ -0,0 +1,144 @@
+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/ClientInstaller.js';
+import { ConfigurationProvider } from './ConfigurationProvider.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);
+        // 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);
+        // Check requirements readiness
+        const requirementsReady = await configProvider.isRequirementsReady(categoryName, serverName);
+        if (!requirementsReady) {
+            // 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
+            const serverConfig = feedConfig.mcpServers.find((s) => s.name === serverName);
+            if (!serverConfig?.dependencies?.requirements) {
+                return {
+                    success: false,
+                    message: 'Server configuration or requirements not found',
+                    status: [{
+                            status: 'failed',
+                            type: 'install',
+                            target: 'server',
+                            message: 'Server configuration or requirements not found'
+                        }]
+                };
+            }
+            // Install requirements asynchronously
+            for (const requirement of serverConfig.dependencies.requirements) {
+                // Create full RequirementConfig from dependency requirement
+                const feeds = await configProvider.getFeedConfiguration(categoryName);
+                const requirementConfig = feeds?.requirements?.find((r) => r.name === requirement.name) || {
+                    name: requirement.name,
+                    version: requirement.version,
+                    type: 'npm' // Default to npm, can be enhanced to determine from requirement or config
+                };
+                const installer = this.installerFactory.getInstaller(requirementConfig);
+                if (!installer) {
+                    await configProvider.updateRequirementStatus(categoryName, requirement.name, {
+                        name: requirement.name,
+                        type: requirementConfig.type,
+                        installed: false,
+                        error: `No installer found for requirement type: ${requirementConfig.type}`,
+                        operationStatus: {
+                            status: 'failed',
+                            type: 'install',
+                            target: 'requirement',
+                            message: `No installer found for requirement type: ${requirementConfig.type}`,
+                            operationId: this.generateOperationId()
+                        }
+                    });
+                    continue;
+                }
+                // Create operation status for requirement
+                const operationStatus = {
+                    status: 'pending',
+                    type: 'install',
+                    target: 'requirement',
+                    message: `Installing requirement: ${requirement.name}`,
+                    operationId: this.generateOperationId()
+                };
+                // Update requirement status
+                await configProvider.updateRequirementStatus(categoryName, requirement.name, {
+                    name: requirement.name,
+                    type: requirementConfig.type,
+                    installed: false,
+                    inProgress: true,
+                    operationStatus
+                });
+                // Start async installation
+                installer.install(requirementConfig).then(async (installStatus) => {
+                    const status = {
+                        ...installStatus,
+                        operationStatus: {
+                            status: installStatus.installed ? 'completed' : 'failed',
+                            type: 'install',
+                            target: 'requirement',
+                            message: installStatus.installed ? `Requirement ${requirement.name} installed successfully` : `Failed to install ${requirement.name}`,
+                            operationId: operationStatus.operationId
+                        }
+                    };
+                    await configProvider.updateRequirementStatus(categoryName, requirement.name, status);
+                });
+            }
+        }
+        // Process client installation regardless of requirements state
+        // Each client installer will check requirements before actual installation
+        return await clientInstaller.install(options);
+    }
+}
+// Export a singleton instance (optional)
+// export const installationService = new InstallationService();
+//# sourceMappingURL=InstallationService.js.map

package/dist/core/MCPManager.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from 'events';
+import { MCPEvent, MCPEventData, MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions } from './types.js';
+export declare class MCPManager extends EventEmitter {
+    private installationService;
+    private configProvider;
+    constructor();
+    syncFeeds(): Promise<void>;
+    initialize(): 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>;
+    uninstallServer(categoryName: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
+    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

@@ -0,0 +1,98 @@
+import { EventEmitter } from 'events';
+import { ConfigurationProvider } from './ConfigurationProvider.js';
+import { InstallationService } from './InstallationService.js';
+import { MCPEvent } from './types.js';
+export class MCPManager extends EventEmitter {
+    installationService;
+    configProvider;
+    constructor() {
+        super();
+        this.configProvider = ConfigurationProvider.getInstance();
+        this.installationService = new InstallationService();
+    }
+    async syncFeeds() {
+        await this.configProvider.syncFeeds();
+    }
+    async initialize() {
+        try {
+            await this.configProvider.initialize();
+        }
+        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 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`,
+                };
+            }
+            // Clear installation status
+            await this.configProvider.updateInstallationStatus(categoryName, {}, {});
+            this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName });
+            return {
+                success: true,
+                message: `Successfully uninstalled ${serverName}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to uninstall ${serverName}`,
+                error: error,
+            };
+        }
+    }
+    // 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

@@ -0,0 +1,45 @@
+import { RequirementConfig, RequirementStatus } 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;
+    /**
+     * Install a requirement
+     * @param requirement The requirement to install
+     * @returns The installation status
+     */
+    installRequirement(requirement: RequirementConfig): Promise<RequirementStatus>;
+    /**
+     * Check the installation status of a requirement
+     * @param requirement The requirement to check
+     * @returns The installation status
+     */
+    checkRequirementStatus(requirement: RequirementConfig): 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): Promise<RequirementStatus>;
+    /**
+     * Install multiple requirements
+     * @param requirements The requirements to install
+     * @returns A map of requirement names to their installation status
+     */
+    installRequirements(requirements: RequirementConfig[]): Promise<Record<string, 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;

package/dist/core/RequirementService.js

@@ -0,0 +1,123 @@
+import { createInstallerFactory } from './installers/index.js';
+import { exec } from 'child_process';
+import util from 'util';
+/**
+ * Service responsible for managing requirements installation and status
+ */
+export class RequirementService {
+    static instance;
+    installerFactory = createInstallerFactory(util.promisify(exec));
+    constructor() { }
+    /**
+     * Get the singleton instance of RequirementService
+     * @returns The RequirementService instance
+     */
+    static getInstance() {
+        if (!RequirementService.instance) {
+            RequirementService.instance = new RequirementService();
+        }
+        return RequirementService.instance;
+    }
+    /**
+     * Install a requirement
+     * @param requirement The requirement to install
+     * @returns The installation status
+     */
+    async installRequirement(requirement) {
+        // Validate requirement
+        this.validateRequirement(requirement);
+        // Install the requirement
+        return await this.installerFactory.install(requirement);
+    }
+    /**
+     * Check the installation status of a requirement
+     * @param requirement The requirement to check
+     * @returns The installation status
+     */
+    async checkRequirementStatus(requirement) {
+        // Validate requirement
+        this.validateRequirement(requirement);
+        // Check the installation status
+        return await this.installerFactory.checkInstallation(requirement);
+    }
+    /**
+     * Check if updates are available for a requirement
+     * @param requirement The requirement to check for updates
+     * @returns Updated status with available updates information
+     */
+    async checkRequirementForUpdates(requirement) {
+        // Validate requirement
+        this.validateRequirement(requirement);
+        // Get current status
+        const status = await this.checkRequirementStatus(requirement);
+        // Check for updates using the appropriate installer
+        const installer = this.installerFactory.getInstaller(requirement);
+        if (!installer) {
+            return status;
+        }
+        // If the installer supports update checking, use it
+        if ('checkForUpdates' in installer) {
+            return await installer.checkForUpdates(requirement, status);
+        }
+        return status;
+    }
+    /**
+     * Install multiple requirements
+     * @param requirements The requirements to install
+     * @returns A map of requirement names to their installation status
+     */
+    async installRequirements(requirements) {
+        const results = {};
+        // Process each requirement sequentially to avoid conflicts
+        for (const requirement of requirements) {
+            results[requirement.name] = await this.installRequirement(requirement);
+        }
+        return results;
+    }
+    /**
+     * Validate a requirement configuration
+     * @param requirement The requirement to validate
+     * @throws Error if the requirement is invalid
+     */
+    validateRequirement(requirement) {
+        // Ensure requirement has required fields
+        if (!requirement.name) {
+            throw new Error('Requirement name is required');
+        }
+        if (!requirement.type) {
+            throw new Error('Requirement type is required');
+        }
+        // For type 'other', registry must be specified
+        if (requirement.type === 'other' && !requirement.registry) {
+            throw new Error('Registry must be specified for requirement type "other"');
+        }
+        // Validate registry configuration if provided
+        if (requirement.registry) {
+            const { githubRelease, artifacts, local } = requirement.registry;
+            // Validate GitHub release configuration
+            if (githubRelease) {
+                if (!githubRelease.repository) {
+                    throw new Error('Repository is required for GitHub release registry');
+                }
+                if (!githubRelease.assetName) {
+                    throw new Error('Asset name is required for GitHub release registry');
+                }
+            }
+            // Validate artifacts registry configuration
+            if (artifacts) {
+                if (!artifacts.registryUrl) {
+                    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');
+                }
+            }
+        }
+    }
+}
+// Export a singleton instance
+export const requirementService = RequirementService.getInstance();
+//# sourceMappingURL=RequirementService.js.map

package/dist/core/constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Defines constants used across the application.
+ */
+/**
+ * GitHub repository configuration for feeds
+ */
+export declare const GITHUB_REPO: {
+    url: string;
+    feedsPath: string;
+};
+/**
+ * Local settings directory path based on OS
+ */
+export declare const SETTINGS_DIR: string;
+/**
+ * Local feeds directory path
+ */
+export declare const LOCAL_FEEDS_DIR: string;
+/**
+ * Supported client configurations.
+ * Key: Client name (e.g., 'vscode')
+ * Value: Client-specific settings or configuration details.
+ * TODO: Define actual client settings structure.
+ */
+export declare const SUPPORTED_CLIENTS: Record<string, any>;
+/**
+ * List of supported client names.
+ */
+export declare const SUPPORTED_CLIENT_NAMES: string[];

package/dist/core/constants.js

@@ -0,0 +1,55 @@
+import os from 'os';
+import path from 'path';
+/**
+ * Defines constants used across the application.
+ */
+/**
+ * GitHub repository configuration for feeds
+ */
+export const GITHUB_REPO = {
+    url: 'https://github.com/ai-microsoft/imcp-feed.git',
+    feedsPath: 'feeds'
+};
+/**
+ * Local settings directory path based on OS
+ */
+export const SETTINGS_DIR = (() => {
+    switch (process.platform) {
+        case 'win32':
+            return path.join(os.homedir(), '.imcp');
+        default: // linux, darwin (macOS), etc.
+            return path.join(os.homedir(), '.imcp');
+    }
+})();
+/**
+ * Local feeds directory path
+ */
+export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
+const CODE_STRORAGE_DIR = path.join(os.homedir(), 'AppData', 'Roaming', 'Code', 'User');
+const CODE_INSIDER_STRORAGE_DIR = path.join(os.homedir(), 'AppData', 'Roaming', 'Code - Insiders', 'User');
+/**
+ * Supported client configurations.
+ * Key: Client name (e.g., 'vscode')
+ * Value: Client-specific settings or configuration details.
+ * TODO: Define actual client settings structure.
+ */
+export const SUPPORTED_CLIENTS = {
+    'Cline': {
+        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+    },
+    'MSRooCode': {
+        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
+        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-clinev', 'settings', 'cline_mcp_settings.json'),
+    },
+    'GithubCopilot': {
+        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'settings.json'),
+        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'settings.json'),
+    },
+    // Add other supported clients here
+};
+/**
+ * List of supported client names.
+ */
+export const SUPPORTED_CLIENT_NAMES = Object.keys(SUPPORTED_CLIENTS);
+//# sourceMappingURL=constants.js.map

package/dist/core/installers/BaseInstaller.d.ts

@@ -0,0 +1,73 @@
+import { RequirementConfig, RequirementStatus, RegistryConfig } from '../types.js';
+import { RequirementInstaller } from './RequirementInstaller.js';
+/**
+ * Abstract base class with common functionality for all requirement installers
+ */
+export declare abstract class BaseInstaller implements RequirementInstaller {
+    protected execPromise: (command: string) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    protected downloadsDir: string;
+    constructor(execPromise: (command: string) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>);
+    abstract canHandle(requirement: RequirementConfig): boolean;
+    abstract install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    abstract checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    /**
+     * Check if updates are available for the requirement
+     * @param requirement The requirement to check
+     * @param currentStatus The current status of the requirement
+     * @returns The status of the requirement with update information
+     */
+    checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
+    /**
+     * Helper method to ensure downloads directory exists
+     */
+    protected ensureDownloadsDir(): Promise<void>;
+    /**
+     * Helper to handle GitHub release downloads
+     * @param requirement The requirement configuration
+     * @param registry The GitHub release registry configuration
+     * @returns The path to the downloaded file
+     */
+    protected handleGitHubRelease(requirement: RequirementConfig, registry: RegistryConfig['githubRelease']): Promise<{
+        resolvedVersion: string;
+        resolvedPath: string;
+    }>;
+    /**
+     * Helper to handle artifact registry downloads
+     * @param requirement The requirement configuration
+     * @param registry The artifacts registry configuration
+     * @returns The registry URL
+     */
+    protected handleArtifactsRegistry(requirement: RequirementConfig, registry: RegistryConfig['artifacts']): Promise<string>;
+    /**
+     * Helper to handle local path registry
+     * @param requirement The requirement configuration
+     * @param registry The local registry configuration
+     * @returns The local path or extracted asset path
+     */
+    protected handleLocalRegistry(requirement: RequirementConfig, registry: RegistryConfig['local']): Promise<string>;
+    private fileExists;
+    /**
+     * Get the latest version available for a GitHub repository
+     * @param repository The GitHub repository in format 'owner/repo'
+     * @returns The latest version or tag
+     */
+    protected getGitHubLatestVersion(repository: string): Promise<string>;
+    /**
+     * Get the latest version available for an NPM package
+     * @param packageName The name of the NPM package
+     * @returns The latest version
+     */
+    protected getNpmLatestVersion(packageName: string): Promise<string>;
+    /**
+     * Get the latest version available for a pip package
+     * @param packageName The name of the pip package
+     * @returns The latest version
+     */
+    protected getPipLatestVersion(packageName: string): Promise<string>;
+}