imcp 0.0.1

package/src/core/ConfigurationProvider.ts

@@ -0,0 +1,489 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR } from './constants.js';
+import { Logger } from '../utils/logger.js';
+import { checkGithubAuth } from '../utils/githubAuth.js';
+import {
+    MCPConfiguration,
+    MCPServerCategory,
+    FeedConfiguration,
+    InstallationStatus,
+    RequirementStatus,
+    MCPServerStatus,
+    OperationStatus
+} from './types.js';
+
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export class ConfigurationProvider {
+    private static instance: ConfigurationProvider;
+    private configPath: string;
+    private configuration: MCPConfiguration;
+    private configLock: Promise<void> = Promise.resolve();
+    private tempDir: string;
+
+    private constructor() {
+        // Initialize configuration in user's appdata/imcp directory
+        this.configPath = path.join(SETTINGS_DIR, 'configurations.json');
+        this.configuration = {
+            localServerCategories: [],
+            feeds: {},
+        };
+        this.tempDir = path.join(LOCAL_FEEDS_DIR, '../temp');
+    }
+
+    public static getInstance(): ConfigurationProvider {
+        if (!ConfigurationProvider.instance) {
+            ConfigurationProvider.instance = new ConfigurationProvider();
+        }
+        return ConfigurationProvider.instance;
+    }
+
+    private async withLock<T>(operation: () => Promise<T>): Promise<T> {
+        const current = this.configLock;
+        let resolve: () => void;
+        this.configLock = new Promise<void>(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        } finally {
+            resolve!();
+        }
+    }
+
+    async initialize(): Promise<void> {
+        await this.withLock(async () => {
+            const configDir = path.dirname(this.configPath);
+            await fs.mkdir(configDir, { recursive: true });
+
+            try {
+                const config = JSON.parse(await fs.readFile(this.configPath, 'utf8'));
+                this.configuration = config;
+                await this.loadFeedsIntoConfiguration(); // Load feeds into configuration
+            } catch (error) {
+                if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+                    throw error;
+                }
+                // File doesn't exist, use default empty configuration
+                await this.saveConfiguration();
+            }
+        });
+    }
+
+    private async saveConfiguration(): Promise<void> {
+        const configDir = path.dirname(this.configPath);
+        await fs.mkdir(configDir, { recursive: true });
+        await fs.writeFile(this.configPath, JSON.stringify(this.configuration, null, 2));
+    }
+
+    async getServerCategories(): Promise<MCPServerCategory[]> {
+        return await this.withLock(async () => {
+            return this.configuration.localServerCategories;
+        });
+    }
+
+    async getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined> {
+        return await this.withLock(async () => {
+            return this.configuration.localServerCategories.find(s => s.name === categoryName);
+        });
+    }
+
+    async getFeedConfiguration(categoryName: string): Promise<FeedConfiguration | undefined> {
+        return await this.withLock(async () => {
+            return this.configuration.feeds[categoryName];
+        });
+    }
+
+    async getInstallationStatus(categoryName: string): Promise<InstallationStatus | undefined> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            return category?.installationStatus;
+        });
+    }
+
+    async getServerStatus(categoryName: string, serverName: string): Promise<MCPServerStatus | undefined> {
+        return await this.withLock(async () => {
+            // Inline getInstallationStatus logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            const status = category?.installationStatus;
+            return status?.serversStatus[serverName];
+        });
+    }
+
+    async getRequirementStatus(categoryName: string, requirementName: string): Promise<RequirementStatus | undefined> {
+        return await this.withLock(async () => {
+            // Inline getInstallationStatus logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            const status = category?.installationStatus;
+            return status?.requirementsStatus[requirementName];
+        });
+    }
+
+    async updateInstallationStatus(
+        categoryName: string,
+        requirementStatus: Record<string, RequirementStatus>,
+        serverStatus: Record<string, MCPServerStatus>
+    ): Promise<boolean> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category) return false;
+
+            if (!category.installationStatus) {
+                category.installationStatus = {
+                    requirementsStatus: {},
+                    serversStatus: {},
+                    lastUpdated: new Date().toISOString()
+                };
+            }
+
+            category.installationStatus.requirementsStatus = {
+                ...category.installationStatus.requirementsStatus,
+                ...requirementStatus
+            };
+
+            category.installationStatus.serversStatus = {
+                ...category.installationStatus.serversStatus,
+                ...serverStatus
+            };
+
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+
+    async updateRequirementStatus(
+        categoryName: string,
+        requirementName: string,
+        status: RequirementStatus
+    ): Promise<boolean> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus) return false;
+
+            category.installationStatus.requirementsStatus[requirementName] = status;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+
+    async updateRequirementOperationStatus(
+        categoryName: string,
+        requirementName: string,
+        operationStatus: OperationStatus
+    ): Promise<boolean> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus?.requirementsStatus[requirementName]) return false;
+
+            category.installationStatus.requirementsStatus[requirementName].operationStatus = operationStatus;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+
+    async updateServerStatus(
+        categoryName: string,
+        serverName: string,
+        status: MCPServerStatus
+    ): Promise<boolean> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus) return false;
+
+            category.installationStatus.serversStatus[serverName] = status;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+
+    async updateServerOperationStatus(
+        categoryName: string,
+        serverName: string,
+        clientName: string,
+        operationStatus: OperationStatus
+    ): Promise<boolean> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus?.serversStatus[serverName]) return false;
+
+            category.installationStatus.serversStatus[serverName].installedStatus[clientName] = operationStatus;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+
+    async isRequirementsReady(categoryName: string, serverName: string): Promise<boolean> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.feedConfiguration) return false;
+
+            const serverConfig = category.feedConfiguration.mcpServers.find(s => s.name === serverName);
+            if (!serverConfig?.dependencies?.requirements) return true; // No requirements means ready
+
+            const requirementNames = serverConfig.dependencies.requirements.map(r => r.name);
+            // Inline getInstallationStatus logic (using the already fetched category)
+            const status = category?.installationStatus;
+
+            if (!status?.requirementsStatus) return false;
+
+            return requirementNames.every(name => {
+                const reqStatus = status.requirementsStatus[name];
+                return reqStatus?.installed && !reqStatus?.error;
+            });
+        });
+    }
+
+    async isServerReady(categoryName: string, serverName: string, clients: string[]): Promise<boolean> {
+        return await this.withLock(async () => {
+            // Inline the logic from getServerStatus and getInstallationStatus to avoid nested lock
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            const installationStatus = category?.installationStatus;
+            const serverStatus = installationStatus?.serversStatus[serverName];
+
+            if (!serverStatus) return false;
+
+            return clients.every(clientName => {
+                // Add optional chaining for safety in case installedStatus is missing
+                const clientStatus = serverStatus.installedStatus?.[clientName];
+                return clientStatus?.status === 'completed' && !clientStatus?.error;
+            });
+        });
+    }
+    async syncFeeds(): Promise<void> {
+        return await this.withLock(async () => {
+            Logger.log('Starting feed synchronization...');
+            try {
+                // Check GitHub authentication first
+                await checkGithubAuth();
+
+                Logger.debug({
+                    action: 'create_directories',
+                    paths: {
+                        localFeeds: LOCAL_FEEDS_DIR,
+                        tempDir: this.tempDir
+                    }
+                });
+
+                await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+                await fs.mkdir(this.tempDir, { recursive: true });
+
+                try {
+                    await fs.access(path.join(this.tempDir, '.git'));
+                    Logger.debug('Found existing repository, updating...');
+                    const { stdout, stderr } = await execAsync('git pull', { cwd: this.tempDir });
+                    Logger.debug({
+                        action: 'git_pull',
+                        stderr,
+                        stdout
+                    });
+                } catch (err) {
+                    Logger.debug('No existing repository found, cloning...');
+                    await fs.rm(this.tempDir, { recursive: true, force: true });
+                    const { stdout, stderr } = await execAsync(`git clone ${GITHUB_REPO.url} ${this.tempDir}`);
+                    Logger.debug({
+                        action: 'git_clone',
+                        stderr,
+                        stdout,
+                        url: GITHUB_REPO.url
+                    });
+                }
+
+                Logger.debug('Updating local feeds...');
+                await fs.rm(LOCAL_FEEDS_DIR, { recursive: true, force: true });
+                const sourceFeedsDir = path.join(this.tempDir, GITHUB_REPO.feedsPath);
+
+                try {
+                    await fs.access(sourceFeedsDir);
+                } catch (err) {
+                    throw new Error(`Could not find feeds directory in cloned repository: ${sourceFeedsDir}`);
+                }
+
+                await fs.cp(sourceFeedsDir, LOCAL_FEEDS_DIR, { recursive: true });
+                Logger.log('Successfully updated local feeds');
+
+                // Update configuration with new feeds
+                await this.loadFeedsIntoConfiguration();
+            } catch (error) {
+                Logger.error('Error during feed synchronization', error);
+                throw new Error('Failed to sync feeds. Use --verbose for detailed error information.');
+            }
+        });
+    }
+
+    private async loadFeedsIntoConfiguration(): Promise<void> {
+        try {
+            await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+            const files = await fs.readdir(LOCAL_FEEDS_DIR);
+            const jsonFiles = files.filter(file => file.endsWith('.json'));
+
+            if (jsonFiles.length === 0) {
+                console.log(`No feed configuration files found in ${LOCAL_FEEDS_DIR}`);
+                return;
+            }
+
+            const feeds: Record<string, FeedConfiguration> = {};
+            for (const file of jsonFiles) {
+                try {
+                    const filePath = path.join(LOCAL_FEEDS_DIR, file);
+                    const content = await fs.readFile(filePath, 'utf8');
+                    const config = JSON.parse(content) as FeedConfiguration;
+                    if (config && config.name) {
+                        feeds[config.name] = config;
+                    }
+                } catch (error) {
+                    console.warn(`Error loading feed configuration from ${file}:`, error);
+                }
+            }
+
+            this.configuration.feeds = feeds;
+            await this.syncServerCategoriesWithFeeds(); // Sync categories after loading feeds
+            await this.saveConfiguration();
+        } catch (error) {
+            console.error("Error loading feed configurations:", error);
+            throw error;
+        }
+    }
+
+    private async syncServerCategoriesWithFeeds(): Promise<void> {
+        let configUpdated = false;
+
+        // 1. Process existing local servers - update their feed configurations
+        for (const server of this.configuration.localServerCategories) {
+            if (this.configuration.feeds[server.name]) {
+                server.feedConfiguration = this.configuration.feeds[server.name];
+                configUpdated = true;
+            }
+
+            // If server doesn't have installation status, initialize it
+            const feedConfig = server.feedConfiguration;
+            // If installationStatus is missing, or requirements/tools are empty, initialize from feed
+            if (
+                !server.installationStatus ||
+                !server.installationStatus.requirementsStatus ||
+                Object.keys(server.installationStatus.requirementsStatus).length === 0 ||
+                !server.installationStatus.serversStatus ||
+                Object.keys(server.installationStatus.serversStatus).length === 0
+            ) {
+                const requirementsStatus: Record<string, RequirementStatus> = {};
+                const serversStatus: Record<string, MCPServerStatus> = {};
+                if (feedConfig) {
+                    if (feedConfig.requirements) {
+                        for (const req of feedConfig.requirements) {
+                            requirementsStatus[req.name] = {
+                                name: req.name,
+                                type: req.type,
+                                installed: false,
+                                version: req.version,
+                                error: undefined,
+                                updateInfo: null
+                            };
+                        }
+                    }
+                    if (feedConfig.mcpServers) {
+                        for (const mcp of feedConfig.mcpServers) {
+                            serversStatus[mcp.name] = {
+                                name: mcp.name,
+                                error: undefined,
+                                installedStatus: {} // Add missing property
+                            };
+                        }
+                    }
+                }
+                server.installationStatus = {
+                    requirementsStatus,
+                    serversStatus,
+                    lastUpdated: new Date().toISOString()
+                };
+                configUpdated = true;
+            }
+        }
+
+        // 2. Check for feeds that don't have a corresponding local server and create new entries
+        const existingServerCategoryNames = new Set(this.configuration.localServerCategories.map(catetory => catetory.name));
+
+        for (const feedName in this.configuration.feeds) {
+            if (!existingServerCategoryNames.has(feedName)) {
+                // This feed doesn't have a corresponding local server - create one with empty installation status
+                const feedConfig = this.configuration.feeds[feedName];
+
+                // Create new server with empty installation status
+                const newServerCategory: MCPServerCategory = {
+                    name: feedName,
+                    displayName: feedConfig.displayName || feedName,
+                    type: 'local',
+                    description: feedConfig.description || `Local MCP server category: ${feedName}`,
+                    installationStatus: (() => {
+                        const requirementsStatus: Record<string, RequirementStatus> = {};
+                        const serversStatus: Record<string, MCPServerStatus> = {};
+                        if (feedConfig) {
+                            if (feedConfig.requirements) {
+                                for (const req of feedConfig.requirements) {
+                                    requirementsStatus[req.name] = {
+                                        name: req.name,
+                                        type: req.type,
+                                        installed: false,
+                                        version: req.version,
+                                        error: undefined
+                                    };
+                                }
+                            }
+                            if (feedConfig.mcpServers) {
+                                for (const mcp of feedConfig.mcpServers) {
+                                    serversStatus[mcp.name] = {
+                                        name: mcp.name,
+                                        error: undefined,
+                                        installedStatus: {} // Add missing property
+                                    };
+                                }
+                            }
+                        }
+                        return {
+                            requirementsStatus,
+                            serversStatus,
+                            lastUpdated: new Date().toISOString()
+                        };
+                    })(),
+                    feedConfiguration: feedConfig
+                };
+
+                // Add the new server to the configuration
+                this.configuration.localServerCategories.push(newServerCategory);
+                console.log(`Created new local server entry for feed: ${feedName}`);
+                configUpdated = true;
+            }
+        }
+
+        if (configUpdated) {
+            await this.saveConfiguration();
+        }
+    }
+
+
+    async syncWithFeed(feedConfiguration: Record<string, FeedConfiguration>): Promise<void> {
+        await this.withLock(async () => {
+            this.configuration.feeds = feedConfiguration;
+            await this.syncServerCategoriesWithFeeds(); // Sync categories after direct update
+            await this.saveConfiguration();
+        });
+    }
+}
+
+// Export a singleton instance
+export const configProvider = ConfigurationProvider.getInstance();

package/src/core/InstallationService.ts

@@ -0,0 +1,173 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
+import util from 'util';
+import {
+  ServerInstallOptions,
+  ServerOperationResult,
+  FeedConfiguration,
+  RequirementConfig,
+  OperationStatus,
+  RequirementStatus,
+  McpConfig
+} from './types.js';
+import { RequirementInstaller, InstallerFactory, 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 {
+  private activeInstallations: Map<string, OperationStatus> = new Map();
+  private installerFactory: InstallerFactory;
+
+  constructor() {
+    this.installerFactory = createInstallerFactory();
+  }
+
+  private generateOperationId(): string {
+    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: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult> {
+    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: McpConfig) => 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: RequirementConfig) => 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: 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: RequirementStatus = {
+            ...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();