imcp 0.0.18 → 0.1.1

package/dist/core/ConfigurationProvider.js

@@ -1,375 +0,0 @@
-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, SUPPORTED_CLIENTS } from './constants.js';
-import { Logger } from '../utils/logger.js';
-import { checkGithubAuth } from '../utils/githubAuth.js';
-import { ConfigurationLoader } from './ConfigurationLoader.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: {},
-            clientMCPSettings: {}
-        };
-        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(feedFile) {
-        await this.withLock(async () => {
-            const configDir = path.dirname(this.configPath);
-            await fs.mkdir(configDir, { recursive: true });
-            try {
-                try {
-                    const config = JSON.parse(await fs.readFile(this.configPath, 'utf8'));
-                    this.configuration = config;
-                }
-                catch (error) {
-                    if (error.code !== 'ENOENT') {
-                        throw error;
-                    }
-                    // File doesn't exist, use default empty configuration
-                    await this.saveConfiguration();
-                }
-                // Always load feeds and client settings, whether file existed or not
-                await this.loadFeedsIntoConfiguration(feedFile);
-                await this.loadClientMCPSettings();
-            }
-            catch (error) {
-                Logger.error('Error during initialization', error);
-                throw error;
-            }
-        });
-    }
-    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 getClientMcpSettings() {
-        return await this.withLock(async () => {
-            return this.configuration.clientMCPSettings;
-        });
-    }
-    async getFeedConfiguration(categoryName) {
-        return await this.withLock(async () => {
-            return this.configuration.feeds[categoryName];
-        });
-    }
-    async getServerMcpConfig(categoryName, serverName) {
-        return await this.withLock(async () => {
-            return this.configuration.feeds[categoryName]?.mcpServers.find(s => s.name === serverName);
-        });
-    }
-    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 GetServerRequirementStatus(categoryName, serverName) {
-        return await this.withLock(async () => {
-            // Inline getServerCategory logic
-            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
-            if (!category?.feedConfiguration)
-                return [];
-            const serverConfig = category.feedConfiguration.mcpServers.find(s => s.name === serverName);
-            if (!serverConfig?.dependencies?.requirements)
-                return [];
-            const requirementNames = serverConfig.dependencies.requirements.map(r => r.name);
-            return requirementNames
-                .map(name => category?.installationStatus?.requirementsStatus[name])
-                .filter(x => x !== undefined);
-        });
-    }
-    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 });
-                // Clean up temp directory
-                await fs.rm(this.tempDir, { recursive: true, force: true });
-                // Download latest release
-                Logger.debug('Downloading latest release...');
-                const { downloadGithubRelease } = await import('../utils/githubUtils.js');
-                const { version, downloadPath } = await downloadGithubRelease(GITHUB_REPO.repoName, 'latest', GITHUB_REPO.feedAssetsName, undefined, true, this.tempDir);
-                Logger.debug({
-                    action: 'download_release',
-                    downloadPath,
-                    version,
-                    repoName: GITHUB_REPO.repoName,
-                });
-                Logger.debug('Updating local feeds...');
-                await fs.rm(LOCAL_FEEDS_DIR, { recursive: true, force: true });
-                const sourceFeedsDir = downloadPath;
-                try {
-                    await fs.access(downloadPath);
-                }
-                catch (err) {
-                    throw new Error(`Could not find feeds directory in downloaded path: ${sourceFeedsDir}`);
-                }
-                await fs.cp(sourceFeedsDir, LOCAL_FEEDS_DIR, { recursive: true, force: true });
-                Logger.log('Successfully updated local feeds');
-            }
-            catch (error) {
-                Logger.error('Error during feed synchronization', error);
-                throw new Error('Failed to sync feeds. Use --verbose for detailed error information.');
-            }
-        });
-    }
-    async loadFeedsIntoConfiguration(feedFile) {
-        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile);
-        await this.saveConfiguration();
-    }
-    async loadClientMCPSettings() {
-        this.configuration = await ConfigurationLoader.loadClientMCPSettings(this.configuration);
-        await this.saveConfiguration();
-    }
-    // Public method to reload client MCP settings
-    async reloadClientMCPSettings() {
-        return await this.withLock(async () => {
-            await this.loadClientMCPSettings();
-        });
-    }
-    async removeServerFromClientMCPSettings(serverName, target) {
-        return await this.withLock(async () => {
-            // Load utils in async context to avoid circular dependencies
-            const { readJsonFile, writeJsonFile } = await import('../utils/clientUtils.js');
-            // Filter clients if target is specified
-            const clientEntries = Object.entries(SUPPORTED_CLIENTS);
-            const targetClients = target
-                ? clientEntries.filter(([clientName]) => clientName === target)
-                : clientEntries;
-            for (const [clientName, clientSettings] of targetClients) {
-                const settingPath = process.env.CODE_INSIDERS
-                    ? clientSettings.codeInsiderSettingPath
-                    : clientSettings.codeSettingPath;
-                try {
-                    const content = await readJsonFile(settingPath, true);
-                    let modified = false;
-                    // Handle GitHub Copilot's different structure
-                    if (clientName === 'GithubCopilot' && content.mcp?.servers?.[serverName]) {
-                        delete content.mcp.servers[serverName];
-                        modified = true;
-                    }
-                    else if (content.mcpServers?.[serverName]) {
-                        delete content.mcpServers[serverName];
-                        modified = true;
-                    }
-                    // Only write if we actually modified the content
-                    if (modified) {
-                        await writeJsonFile(settingPath, content);
-                        Logger.debug(`Removed server ${serverName} from client ${clientName} settings`);
-                    }
-                }
-                catch (error) {
-                    Logger.error(`Failed to remove server ${serverName} from client ${clientName} settings:`, error);
-                }
-            }
-            // Also update our in-memory configuration
-            if (this.configuration.clientMCPSettings) {
-                if (target) {
-                    // Only update settings for the target client
-                    const clientSettings = this.configuration.clientMCPSettings[target];
-                    if (clientSettings) {
-                        if (clientSettings.mcpServers?.[serverName]) {
-                            delete clientSettings.mcpServers[serverName];
-                        }
-                        if (clientSettings.servers?.[serverName]) { // For GitHub Copilot
-                            delete clientSettings.servers[serverName];
-                        }
-                    }
-                }
-                else {
-                    // Update all clients if no target specified
-                    for (const clientSettings of Object.values(this.configuration.clientMCPSettings)) {
-                        if (clientSettings.mcpServers?.[serverName]) {
-                            delete clientSettings.mcpServers[serverName];
-                        }
-                        if (clientSettings.servers?.[serverName]) { // For GitHub Copilot
-                            delete clientSettings.servers[serverName];
-                        }
-                    }
-                }
-                await this.saveConfiguration();
-            }
-        });
-    }
-}
-// Export a singleton instance
-export const configProvider = ConfigurationProvider.getInstance();
-//# sourceMappingURL=ConfigurationProvider.js.map

package/dist/core/InstallationService.d.ts

@@ -1,50 +0,0 @@
-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>;
-    /**
-     * Process requirement updates specified in serverInstallOptions
-     * All updates are processed in parallel for maximum efficiency
-     * @param categoryName The category name
-     * @param serverName The server name
-     * @param requirements The requirements to update
-     */
-    private processRequirementUpdates;
-    /**
-     * Checks and installs requirements for a server if needed
-     * @param categoryName The category name
-     * @param serverName The server name
-     * @param options The installation options
-     * @returns A failure result if requirements check fails, null if requirements are satisfied
-     */
-    private checkAndInstallRequirements;
-    /**
-     * Installs requirements in background without blocking the main thread
-     * Requirements with the same order are installed in parallel
-     */
-    private installRequirementsInBackground;
-    /**
-     * Helper to update requirement status for failure case
-     */
-    private updateRequirementFailureStatus;
-    /**
-     * Helper to update requirement status for in-progress case
-     */
-    private updateRequirementProgressStatus;
-    /**
-     * Helper to update requirement status for completion case
-     */
-    private updateRequirementCompletionStatus;
-}