imcp 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createServeCommand } from './commands/serve.js';
+import { createListCommand } from './commands/list.js';
+import { createInstallCommand } from './commands/install.js';
+import { createPullCommand } from './commands/pull.js';
+import { mcpManager } from '../core/MCPManager.js';
+import { Logger } from '../utils/logger.js';
+import axios from 'axios';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+// Custom error interface for Commander.js errors
+// ANSI color codes
+const COLORS = {
+    reset: '\x1b[0m',
+    yellow: '\x1b[33m'
+};
+async function main() {
+    // Initialize the MCP manager
+    await mcpManager.initialize();
+    const program = new Command();
+    program
+        .name('imcp')
+        .description('IMCP (Install Model Context Protocol) CLI')
+        .version('0.0.1')
+        .option('--verbose', 'Show detailed logs for all commands');
+    // Parse global options first
+    program.parseOptions(process.argv);
+    const opts = program.opts();
+    Logger.setVerbose(!!opts.verbose);
+    // Add all commands
+    program.addCommand(createServeCommand());
+    program.addCommand(createListCommand());
+    program.addCommand(createInstallCommand());
+    // program.addCommand(createUninstallCommand());
+    program.addCommand(createPullCommand());
+    // Error handling for the entire CLI
+    program.exitOverride();
+    // Check for updates
+    await checkForUpdates();
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        const commanderError = error;
+        if (commanderError.code === 'commander.help') {
+            // Help was displayed, exit normally
+            process.exit(0);
+        }
+        else if (commanderError.code === 'commander.version') {
+            // Version was displayed, exit normally
+            process.exit(0);
+        }
+        else {
+            console.error('Error:', commanderError.message || 'An unknown error occurred');
+            process.exit(1);
+        }
+    }
+}
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (error) => {
+    if (error instanceof Error) {
+        console.error('Unhandled promise rejection:', error.message);
+    }
+    else {
+        console.error('Unhandled promise rejection:', error);
+    }
+    process.exit(1);
+});
+/**
+ * Check if there's a newer version of the package available
+ */
+async function checkForUpdates() {
+    try {
+        // Get the current package version
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const packagePath = path.resolve(__dirname, '../../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        const currentVersion = packageJson.name && packageJson.version ? packageJson.version : '0.0.0';
+        const packageName = packageJson.name || 'imcp';
+        try {
+            // Get the latest version from npm registry (only for published packages)
+            const npmResponse = await axios.get(`https://registry.npmjs.org/${packageName}`);
+            if (npmResponse.data && npmResponse.data['dist-tags'] && npmResponse.data['dist-tags'].latest) {
+                const latestVersion = npmResponse.data['dist-tags'].latest;
+                if (latestVersion && latestVersion !== currentVersion) {
+                    console.log(`${COLORS.yellow}Update available for ${packageName}: ${currentVersion} → ${latestVersion}${COLORS.reset}`);
+                    console.log(`${COLORS.yellow}Run \`npm install -g ${packageName}@latest\` to update${COLORS.reset}`);
+                }
+            }
+        }
+        catch (npmError) {
+            // Log the npm error
+            Logger.debug(`Failed to check npm registry: ${npmError instanceof Error ? npmError.message : String(npmError)}`);
+        }
+    }
+    catch (error) {
+        // Silently fail - don't interrupt the command if update check fails
+        Logger.debug(`Failed to check for updates: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// Start the CLI
+main().catch((error) => {
+    if (error instanceof Error) {
+        console.error('Fatal error:', error.message);
+    }
+    else {
+        console.error('Fatal error:', error);
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/core/ConfigurationProvider.d.ts

@@ -0,0 +1,31 @@
+import { MCPServerCategory, FeedConfiguration, InstallationStatus, RequirementStatus, MCPServerStatus, OperationStatus } from './types.js';
+export declare class ConfigurationProvider {
+    private static instance;
+    private configPath;
+    private configuration;
+    private configLock;
+    private tempDir;
+    private constructor();
+    static getInstance(): ConfigurationProvider;
+    private withLock;
+    initialize(): Promise<void>;
+    private saveConfiguration;
+    getServerCategories(): Promise<MCPServerCategory[]>;
+    getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;
+    getFeedConfiguration(categoryName: string): Promise<FeedConfiguration | undefined>;
+    getInstallationStatus(categoryName: string): Promise<InstallationStatus | undefined>;
+    getServerStatus(categoryName: string, serverName: string): Promise<MCPServerStatus | undefined>;
+    getRequirementStatus(categoryName: string, requirementName: string): Promise<RequirementStatus | undefined>;
+    updateInstallationStatus(categoryName: string, requirementStatus: Record<string, RequirementStatus>, serverStatus: Record<string, MCPServerStatus>): Promise<boolean>;
+    updateRequirementStatus(categoryName: string, requirementName: string, status: RequirementStatus): Promise<boolean>;
+    updateRequirementOperationStatus(categoryName: string, requirementName: string, operationStatus: OperationStatus): Promise<boolean>;
+    updateServerStatus(categoryName: string, serverName: string, status: MCPServerStatus): Promise<boolean>;
+    updateServerOperationStatus(categoryName: string, serverName: string, clientName: string, operationStatus: OperationStatus): Promise<boolean>;
+    isRequirementsReady(categoryName: string, serverName: string): Promise<boolean>;
+    isServerReady(categoryName: string, serverName: string, clients: string[]): Promise<boolean>;
+    syncFeeds(): Promise<void>;
+    private loadFeedsIntoConfiguration;
+    private syncServerCategoriesWithFeeds;
+    syncWithFeed(feedConfiguration: Record<string, FeedConfiguration>): Promise<void>;
+}
+export declare const configProvider: ConfigurationProvider;

package/dist/core/ConfigurationProvider.js

@@ -0,0 +1,416 @@
+import fs from 'fs/promises';
+import path from 'path';
+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';
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export class ConfigurationProvider {
+    static instance;
+    configPath;
+    configuration;
+    configLock = Promise.resolve();
+    tempDir;
+    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');
+    }
+    static getInstance() {
+        if (!ConfigurationProvider.instance) {
+            ConfigurationProvider.instance = new ConfigurationProvider();
+        }
+        return ConfigurationProvider.instance;
+    }
+    async withLock(operation) {
+        const current = this.configLock;
+        let resolve;
+        this.configLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async initialize() {
+        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.code !== 'ENOENT') {
+                    throw error;
+                }
+                // File doesn't exist, use default empty configuration
+                await this.saveConfiguration();
+            }
+        });
+    }
+    async saveConfiguration() {
+        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() {
+        return await this.withLock(async () => {
+            return this.configuration.localServerCategories;
+        });
+    }
+    async getServerCategory(categoryName) {
+        return await this.withLock(async () => {
+            return this.configuration.localServerCategories.find(s => s.name === categoryName);
+        });
+    }
+    async getFeedConfiguration(categoryName) {
+        return await this.withLock(async () => {
+            return this.configuration.feeds[categoryName];
+        });
+    }
+    async getInstallationStatus(categoryName) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            return category?.installationStatus;
+        });
+    }
+    async getServerStatus(categoryName, serverName) {
+        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, requirementName) {
+        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, requirementStatus, serverStatus) {
+        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, requirementName, status) {
+        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, requirementName, operationStatus) {
+        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, serverName, status) {
+        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, serverName, clientName, operationStatus) {
+        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, serverName) {
+        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, serverName, clients) {
+        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() {
+        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.');
+            }
+        });
+    }
+    async loadFeedsIntoConfiguration() {
+        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 = {};
+            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);
+                    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;
+        }
+    }
+    async syncServerCategoriesWithFeeds() {
+        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 = {};
+                const serversStatus = {};
+                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 = {
+                    name: feedName,
+                    displayName: feedConfig.displayName || feedName,
+                    type: 'local',
+                    description: feedConfig.description || `Local MCP server category: ${feedName}`,
+                    installationStatus: (() => {
+                        const requirementsStatus = {};
+                        const serversStatus = {};
+                        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) {
+        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();
+//# sourceMappingURL=ConfigurationProvider.js.map

package/dist/core/InstallationService.d.ts

@@ -0,0 +1,17 @@
+import { ServerInstallOptions, ServerOperationResult } from './types.js';
+/**
+ * Handles the actual installation process for an MCP server.
+ */
+export declare class InstallationService {
+    private activeInstallations;
+    private installerFactory;
+    constructor();
+    private generateOperationId;
+    /**
+     * 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.
+     */
+    install(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult>;
+}