imcp 0.0.1

package/src/core/MCPManager.ts

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'events';
+import { ConfigurationProvider } from './ConfigurationProvider.js';
+import { InstallationService } from './InstallationService.js';
+import {
+  MCPEvent,
+  MCPEventData,
+  MCPServerCategory,
+  ServerInstallOptions,
+  ServerCategoryListOptions,
+  ServerOperationResult,
+  ServerUninstallOptions,
+  InstallationStatus
+} from './types.js';
+import path from 'path';
+
+export class MCPManager extends EventEmitter {
+  private installationService: InstallationService;
+  private configProvider: ConfigurationProvider;
+
+  constructor() {
+    super();
+    this.configProvider = ConfigurationProvider.getInstance();
+    this.installationService = new InstallationService();
+  }
+
+  async syncFeeds(): Promise<void> {
+    await this.configProvider.syncFeeds();
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      await this.configProvider.initialize();
+    } catch (error) {
+      console.error("Error during MCPManager initialization:", error);
+      throw error;
+    }
+  }
+
+  async listServerCategories(options: ServerCategoryListOptions = {}): Promise<MCPServerCategory[]> {
+    const { local = true } = options;
+    if (local) {
+      return await this.configProvider.getServerCategories();
+    }
+    return [];
+  }
+
+  async getFeedConfiguration(categoryName: string) {
+    return this.configProvider.getFeedConfiguration(categoryName);
+  }
+
+  async installServer(
+    categoryName: string,
+    serverName: string,
+    requestOptions: ServerInstallOptions = {}
+  ): Promise<ServerOperationResult> {
+    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: string,
+    serverName: string,
+    options: ServerUninstallOptions = {}
+  ): Promise<ServerOperationResult> {
+    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 as Error,
+      };
+    }
+  }
+
+  // Type-safe event emitter methods
+  emit<E extends MCPEvent>(event: E, data: MCPEventData[E]): boolean {
+    return super.emit(event, data);
+  }
+
+  on<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this {
+    return super.on(event, listener);
+  }
+
+  off<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this {
+    return super.off(event, listener);
+  }
+}
+
+// Export a singleton instance
+export const mcpManager = new MCPManager();

package/src/core/RequirementService.ts

@@ -0,0 +1,147 @@
+import { RequirementConfig, RequirementStatus } from './types.js';
+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 {
+    private static instance: RequirementService;
+    private installerFactory = createInstallerFactory(util.promisify(exec));
+
+    private constructor() { }
+
+    /**
+     * Get the singleton instance of RequirementService
+     * @returns The RequirementService instance
+     */
+    public static getInstance(): RequirementService {
+        if (!RequirementService.instance) {
+            RequirementService.instance = new RequirementService();
+        }
+        return RequirementService.instance;
+    }
+
+    /**
+     * Install a requirement
+     * @param requirement The requirement to install
+     * @returns The installation status
+     */
+    public async installRequirement(requirement: RequirementConfig): Promise<RequirementStatus> {
+        // 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
+     */
+    public async checkRequirementStatus(requirement: RequirementConfig): Promise<RequirementStatus> {
+        // 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
+     */
+    public async checkRequirementForUpdates(requirement: RequirementConfig): Promise<RequirementStatus> {
+        // 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 as any).checkForUpdates(requirement, status);
+        }
+
+        return status;
+    }
+
+    /**
+     * Install multiple requirements
+     * @param requirements The requirements to install
+     * @returns A map of requirement names to their installation status
+     */
+    public async installRequirements(requirements: RequirementConfig[]): Promise<Record<string, RequirementStatus>> {
+        const results: Record<string, RequirementStatus> = {};
+
+        // 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
+     */
+    private validateRequirement(requirement: RequirementConfig): void {
+        // 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();

package/src/core/constants.ts

@@ -0,0 +1,61 @@
+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: Record<string, any> = {
+  'Cline': { /* VS Code specific settings */
+    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': { /* MSROO specific settings */
+    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': { /* GitHub Copilot specific settings */
+    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);

package/src/core/installers/BaseInstaller.ts

@@ -0,0 +1,292 @@
+import { RequirementConfig, RequirementStatus, RegistryConfig } from '../types.js';
+import path from 'path';
+import fs from 'fs/promises';
+import { SETTINGS_DIR } from '../constants.js';
+import { extractZipFile } from '../../utils/clientUtils.js';
+import { RequirementInstaller } from './RequirementInstaller.js';
+
+/**
+ * Abstract base class with common functionality for all requirement installers
+ */
+export 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 }>) {
+        this.execPromise = execPromise;
+        this.downloadsDir = path.join(SETTINGS_DIR, 'downloads');
+    }
+
+    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
+     */
+    async checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus> {
+        try {
+            // If requirement is not installed, no need to check for updates
+            if (!currentStatus.installed) {
+                return currentStatus;
+            }
+            
+            // If the version doesn't contain "latest", no update check needed
+            if (!requirement.version.includes('latest')) {
+                return currentStatus;
+            }
+            
+            let latestVersion: string | undefined;
+            
+            // Check based on registry type
+            if (requirement.registry?.githubRelease) {
+                latestVersion = await this.getGitHubLatestVersion(requirement.registry.githubRelease.repository);
+            } else {
+                // Use common practice based on requirement type
+                switch (requirement.type) {
+                    case 'npm':
+                        latestVersion = await this.getNpmLatestVersion(requirement.name);
+                        break;
+                    case 'pip':
+                        latestVersion = await this.getPipLatestVersion(requirement.name);
+                        break;
+                    // Add other types as needed
+                }
+            }
+            
+            // If we found a latest version and it's different from current
+            if (latestVersion && latestVersion !== currentStatus.version) {
+                return {
+                    ...currentStatus,
+                    availableUpdate: {
+                        version: latestVersion,
+                        message: `Update available: ${currentStatus.version} → ${latestVersion}`,
+                        checkTime: new Date().toISOString()
+                    }
+                };
+            }
+            
+            return currentStatus;
+        } catch (error) {
+            // Don't update status on error, just log it
+            console.warn(`Error checking for updates for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            return currentStatus;
+        }
+    }
+
+    /**
+     * Helper method to ensure downloads directory exists
+     */
+    protected async ensureDownloadsDir(): Promise<void> {
+        await fs.mkdir(this.downloadsDir, { recursive: true });
+    }
+
+    /**
+     * 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 async handleGitHubRelease(
+        requirement: RequirementConfig,
+        registry: RegistryConfig['githubRelease']
+    ): Promise<{ resolvedVersion: string; resolvedPath: string }> {
+        if (!registry) {
+            throw new Error('GitHub release registry configuration is required');
+        }
+
+        await this.ensureDownloadsDir();
+        const { repository, assetsName, assetName } = registry;
+
+        if (!repository) {
+            throw new Error('GitHub repository is required for GitHub release downloads');
+        }
+
+        let version = requirement.version;
+        let resolvedAssetName = assetName || '';
+        let resolvedAssetsName = assetsName || '';
+
+        // Handle latest version detection
+        if (version.includes('${latest}') || version === 'latest') {
+            const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+            const latestTag = stdout.trim();
+            let latestVersion = latestTag
+            if (latestVersion.startsWith('v') && version.startsWith('v')) {
+                latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
+                // Replace ${latest} in version and asset names
+                version = version.replace('${latest}', latestVersion);
+                if (assetsName) {
+                    resolvedAssetsName = assetsName.replace('${latest}', latestVersion);
+                }
+                if (assetName) {
+                    resolvedAssetName = assetName.replace('${latest}', latestVersion);
+                }
+            }
+        }
+        const pattern = resolvedAssetsName ? resolvedAssetsName : resolvedAssetName;
+
+        if (!pattern) {
+            throw new Error('Either assetsName or assetName must be specified for GitHub release downloads');
+        }
+
+        // Download the release asset
+        const downloadPath = path.join(this.downloadsDir, path.basename(pattern));
+        if (!await this.fileExists(downloadPath)) {
+            await this.execPromise(`gh release download ${version} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
+        }
+
+        // Handle zip file extraction if the downloaded file is a zip
+        if (downloadPath.endsWith('.zip')) {
+            const extractDir = path.join(this.downloadsDir, path.basename(pattern, '.zip'));
+            await fs.mkdir(extractDir, { recursive: true });
+
+            // Extract the zip file
+            await extractZipFile(downloadPath, { dir: extractDir });
+            let assetPath = '';
+            // If resolvedAssetName is specified, look for it in the extracted directory
+            if (resolvedAssetName) {
+                assetPath = path.join(extractDir, resolvedAssetName);
+                try {
+                    await fs.access(assetPath);
+                    return { resolvedVersion: version, resolvedPath: assetPath };
+                } catch (error) {
+                    throw new Error(`Asset ${resolvedAssetName} not found in extracted directory ${extractDir}`);
+                }
+            }
+            else {
+                assetPath = path.join(extractDir, path.basename(pattern, '.zip') + '.tgz');
+            }
+
+            // If no specific asset is required, return the extraction directory
+            return { resolvedVersion: version, resolvedPath: extractDir };
+        }
+
+        return { resolvedVersion: version, resolvedPath: downloadPath };
+    }
+
+    /**
+     * Helper to handle artifact registry downloads
+     * @param requirement The requirement configuration
+     * @param registry The artifacts registry configuration
+     * @returns The registry URL
+     */
+    protected async handleArtifactsRegistry(
+        requirement: RequirementConfig,
+        registry: RegistryConfig['artifacts']
+    ): Promise<string> {
+        if (!registry) {
+            throw new Error('Artifacts registry configuration is required');
+        }
+
+        const { registryUrl, assetName } = registry;
+
+        if (!registryUrl) {
+            throw new Error('Registry URL is required for artifacts downloads');
+        }
+
+        return registryUrl;
+    }
+
+    /**
+     * 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 async handleLocalRegistry(
+        requirement: RequirementConfig,
+        registry: RegistryConfig['local']
+    ): Promise<string> {
+        if (!registry) {
+            throw new Error('Local registry configuration is required');
+        }
+
+        const { localPath, assetName } = registry;
+
+        if (!localPath) {
+            throw new Error('Local path is required for local registry');
+        }
+
+        // Verify the local path exists
+        try {
+            await fs.access(localPath);
+        } catch (error) {
+            throw new Error(`Local path ${localPath} does not exist or is not accessible`);
+        }
+
+        // If the path is a zip file and assetName is specified, extract it
+        if (localPath.endsWith('.zip') && assetName) {
+            const extractDir = path.join(this.downloadsDir, path.basename(localPath, '.zip'));
+            await fs.mkdir(extractDir, { recursive: true });
+
+            // Extract the zip file
+            await extractZipFile(localPath, { dir: extractDir });
+
+            // Find the asset in the extracted directory
+            const assetPath = path.join(extractDir, assetName);
+            try {
+                await fs.access(assetPath);
+                return assetPath;
+            } catch (error) {
+                throw new Error(`Asset ${assetName} not found in extracted directory ${extractDir}`);
+            }
+        }
+
+        return localPath;
+    }
+
+    private async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await fs.access(filePath)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    /**
+     * 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 async getGitHubLatestVersion(repository: string): Promise<string> {
+        try {
+            // Use GitHub CLI to get the latest release
+            const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+            const latestTag = stdout.trim();
+            
+            // Remove 'v' prefix if present
+            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+        } catch (error) {
+            // If gh command fails, try to get the latest tag
+            const { stdout } = await this.execPromise(`git ls-remote --tags --refs https://github.com/${repository}.git | sort -t '/' -k 3 -V | tail -n 1 | awk -F/ '{print $3}'`);
+            let latestTag = stdout.trim();
+            
+            // Remove 'v' prefix if present
+            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+        }
+    }
+
+    /**
+     * Get the latest version available for an NPM package
+     * @param packageName The name of the NPM package
+     * @returns The latest version
+     */
+    protected async getNpmLatestVersion(packageName: string): Promise<string> {
+        const { stdout } = await this.execPromise(`npm view ${packageName} version`);
+        return stdout.trim();
+    }
+
+    /**
+     * Get the latest version available for a pip package
+     * @param packageName The name of the pip package
+     * @returns The latest version
+     */
+    protected async getPipLatestVersion(packageName: string): Promise<string> {
+        const { stdout } = await this.execPromise(`pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
+        return stdout.trim();
+    }
+}