imcp 0.0.1

package/src/core/installers/ClientInstaller.ts

@@ -0,0 +1,423 @@
+import {
+    ServerOperationResult,
+    OperationStatus,
+    MCPServerStatus,
+    RequirementStatus,
+    ServerInstallOptions,
+    FeedConfiguration,
+    McpConfig
+} from '../types.js';
+import { ConfigurationProvider } from '../ConfigurationProvider.js';
+import { SUPPORTED_CLIENTS } from '../constants.js';
+import { resolveNpmModulePath, readJsonFile, writeJsonFile } from '../../utils/clientUtils.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+export class ClientInstaller {
+    private configProvider: ConfigurationProvider;
+    private operationStatuses: Map<string, OperationStatus>;
+
+    constructor(
+        private categoryName: string,
+        private serverName: string,
+        private clients: string[]
+    ) {
+        this.configProvider = ConfigurationProvider.getInstance();
+        this.operationStatuses = new Map();
+    }
+
+    private generateOperationId(): string {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    private async getNpmPath(): Promise<string> {
+        const execAsync = promisify(exec);
+        try {
+            // Execute the get-command npm command to find the npm path
+            const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
+
+            // Extract the directory from the full path (removing npm.cmd)
+            const npmPath = stdout.trim().replace(/\\npm\.cmd$/, '');
+            return npmPath;
+        } catch (error) {
+            console.error('Error getting npm path:', error);
+            // Return a default path if the command fails
+            return 'C:\\Program Files\\nodejs';
+        }
+    }
+
+    private async installClient(clientName: string, env?: Record<string, string>): Promise<OperationStatus> {
+        // Check if client is supported
+        if (!SUPPORTED_CLIENTS[clientName]) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unsupported client: ${clientName}`,
+                operationId: this.generateOperationId()
+            };
+        }
+
+        // Create initial operation status
+        const operationId = this.generateOperationId();
+        const initialStatus: OperationStatus = {
+            status: 'pending',
+            type: 'install',
+            target: 'server',
+            message: `Initializing installation for client: ${clientName}`,
+            operationId: operationId
+        };
+
+        // Update server status with initial client installation status
+        await this.configProvider.updateServerOperationStatus(
+            this.categoryName,
+            this.serverName,
+            clientName,
+            initialStatus
+        );
+
+        // Start the asynchronous installation process without awaiting it
+        this.processInstallation(clientName, operationId, env);
+
+        // Return the initial status immediately
+        return initialStatus;
+    }
+
+    private async processInstallation(clientName: string, operationId: string, env?: Record<string, string>): Promise<void> {
+        try {
+            // Check requirements before installation
+            let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+
+            // If requirements are not ready, periodically check with timeout
+            if (!requirementsReady) {
+                const pendingStatus: OperationStatus = {
+                    status: 'pending',
+                    type: 'install',
+                    target: 'server',
+                    message: `Waiting for requirements to be ready for client: ${clientName}`,
+                    operationId: operationId
+                };
+
+                // Update status to pending with reference to configProvider
+                await this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    pendingStatus
+                );
+
+                // Set up periodic checking with timeout
+                const startTime = Date.now();
+                const timeoutMs = 5 * 60 * 1000; // 5 minutes in milliseconds
+                const intervalMs = 5 * 1000; // 5 seconds in milliseconds
+
+                while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
+                    // Wait for the interval
+                    await new Promise(resolve => setTimeout(resolve, intervalMs));
+
+                    // Check again
+                    requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+                }
+
+                // If still not ready after timeout, update status as failed and exit
+                if (!requirementsReady) {
+                    const failedStatus: OperationStatus = {
+                        status: 'failed',
+                        type: 'install',
+                        target: 'server',
+                        message: `Timed out waiting for requirements to be ready for client: ${clientName} after 5 minutes`,
+                        operationId: operationId
+                    };
+
+                    await this.configProvider.updateServerOperationStatus(
+                        this.categoryName,
+                        this.serverName,
+                        clientName,
+                        failedStatus
+                    );
+
+                    return; // Exit the installation process
+                }
+            }
+
+            // If we've reached here, requirements are ready - update status to in-progress
+            const inProgressStatus: OperationStatus = {
+                status: 'in-progress',
+                type: 'install',
+                target: 'server',
+                message: `Installing client: ${clientName}`,
+                operationId: operationId
+            };
+
+            await this.configProvider.updateServerOperationStatus(
+                this.categoryName,
+                this.serverName,
+                clientName,
+                inProgressStatus
+            );
+
+            // Get feed configuration for the server
+            const feedConfiguration = await this.configProvider.getFeedConfiguration(this.categoryName);
+            if (!feedConfiguration) {
+                const errorStatus: OperationStatus = {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: `Failed to get feed configuration for category: ${this.categoryName}`,
+                    operationId: operationId
+                };
+                await this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    errorStatus
+                );
+                return;
+            }
+
+            // Find the server config in the feed configuration
+            const serverConfig = feedConfiguration.mcpServers.find(s => s.name === this.serverName);
+            if (!serverConfig) {
+                const errorStatus: OperationStatus = {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: `Server ${this.serverName} not found in feed configuration`,
+                    operationId: operationId
+                };
+                await this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    errorStatus
+                );
+                return;
+            }
+
+            try {
+                // Install client-specific configuration
+                const result = await this.installClientConfig(clientName, env || {}, serverConfig, feedConfiguration);
+
+                const finalStatus: OperationStatus = {
+                    status: result.success ? 'completed' : 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: result.message || `Installation for client ${clientName}: ${result.success ? 'successful' : 'failed'}`,
+                    operationId: operationId,
+                    error: result.success ? undefined : result.message
+                };
+
+                await this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    finalStatus
+                );
+
+            } catch (error) {
+                const errorStatus: OperationStatus = {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: `Failed to install client: ${clientName}. Error: ${error instanceof Error ? error.message : String(error)}`,
+                    operationId: operationId,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+
+                await this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    errorStatus
+                );
+            }
+        } catch (error) {
+            const errorStatus: OperationStatus = {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error in installation process for client: ${clientName}. Error: ${error instanceof Error ? error.message : String(error)}`,
+                operationId: operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+
+            await this.configProvider.updateServerOperationStatus(
+                this.categoryName,
+                this.serverName,
+                clientName,
+                errorStatus
+            );
+        }
+    }
+
+    private async installClientConfig(
+        clientName: string,
+        env: Record<string, string>,
+        serverConfig: McpConfig,
+        feedConfig: FeedConfiguration
+    ): Promise<{ success: boolean; message: string }> {
+        try {
+            if (!SUPPORTED_CLIENTS[clientName]) {
+                return { success: false, message: `Unsupported client: ${clientName}` };
+            }
+
+            const clientSettings = SUPPORTED_CLIENTS[clientName];
+
+            // Determine which setting path to use based on VS Code type (regular or insiders)
+            const settingPath = process.env.CODE_INSIDERS
+                ? clientSettings.codeInsiderSettingPath
+                : clientSettings.codeSettingPath;
+
+            if (!settingPath) {
+                return { success: false, message: `No settings path found for client: ${clientName}` };
+            }
+
+            // Clone the installation configuration to make modifications
+            const installConfig = JSON.parse(JSON.stringify(serverConfig.installation));
+
+            // Replace template variables in args
+            installConfig.args = installConfig.args.map((arg: string) =>
+                resolveNpmModulePath(arg));
+
+            // Add environment variables from options
+            installConfig.env = {};
+            if (serverConfig.installation.env) {
+                // Add default env variables from config
+                for (const [key, config] of Object.entries(serverConfig.installation.env)) {
+                    const envConfig = config as any; // Type assertion for dynamic access
+                    if (envConfig.Default) {
+                        installConfig.env[key] = envConfig.Default;
+                    }
+                }
+            }
+
+            // Override with provided env variables
+            if (env) {
+                Object.assign(installConfig.env, env);
+            }
+
+            // Update client-specific settings
+            if (clientName === 'MSRooCode' || clientName === 'Cline') {
+                await this.updateClineOrMSRooSettings(settingPath, this.serverName, installConfig, clientName);
+            } else if (clientName === 'GithubCopilot') {
+                await this.updateGithubCopilotSettings(settingPath, this.serverName, installConfig);
+            } else {
+                return {
+                    success: false,
+                    message: `Client ${clientName} is supported but no implementation exists for updating its settings`
+                };
+            }
+
+            return {
+                success: true,
+                message: `Successfully installed ${this.serverName} for client: ${clientName}`
+            };
+        } catch (error) {
+            return {
+                success: false,
+                message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+
+    private async updateClineOrMSRooSettings(
+        settingPath: string,
+        serverName: string,
+        installConfig: any,
+        clientName: string
+    ): Promise<void> {
+        // Read the Cline/MSRoo settings file
+        const settings = await readJsonFile(settingPath, true);
+
+        // Initialize mcpServers section if it doesn't exist
+        if (!settings.mcpServers) {
+            settings.mcpServers = {};
+        }
+
+        // Special handling for Windows when command is npx for Cline and MSROO clients
+        const serverConfig = { ...installConfig };
+        if (process.platform === 'win32' &&
+            serverConfig.command === 'npx' &&
+            (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
+            // Update command to cmd
+            serverConfig.command = 'cmd';
+
+            // Add /c and npx at the beginning of args
+            serverConfig.args = ['/c', 'npx', ...serverConfig.args];
+
+            // Add APPDATA environment variable pointing to npm directory
+            if (!serverConfig.env) {
+                serverConfig.env = {};
+            }
+
+            // Dynamically get npm path and set APPDATA to it
+            const npmPath = await this.getNpmPath();
+            serverConfig.env['APPDATA'] = npmPath;
+        }
+
+        // Add or update the server configuration
+        settings.mcpServers[serverName] = {
+            command: serverConfig.command,
+            args: serverConfig.args,
+            env: serverConfig.env,
+            autoApprove: [],
+            disabled: false,
+            alwaysAllow: []
+        };
+
+        // Write the updated settings back to the file
+        await writeJsonFile(settingPath, settings);
+    }
+
+    private async updateGithubCopilotSettings(
+        settingPath: string,
+        serverName: string,
+        installConfig: any
+    ): Promise<void> {
+        // Read the VS Code settings.json file
+        const settings = await readJsonFile(settingPath, true);
+
+        // Initialize the mcp section if it doesn't exist
+        if (!settings.mcp) {
+            settings.mcp = {
+                servers: {},
+                inputs: []
+            };
+        }
+
+        if (!settings.mcp.servers) {
+            settings.mcp.servers = {};
+        }
+
+        // Add or update the server configuration
+        settings.mcp.servers[serverName] = {
+            command: installConfig.command,
+            args: installConfig.args,
+            env: installConfig.env
+        };
+
+        // Write the updated settings back to the file
+        await writeJsonFile(settingPath, settings);
+    }
+
+    async install(options: ServerInstallOptions): Promise<ServerOperationResult> {
+        const initialStatuses: OperationStatus[] = [];
+
+        // Start installation for each client asynchronously and collect initial statuses
+        const installPromises = this.clients.map(async (clientName) => {
+            const initialStatus = await this.installClient(clientName, options.env || {});
+            initialStatuses.push(initialStatus);
+            return initialStatus;
+        });
+
+        // Wait for all initial statuses (but actual installation continues asynchronously)
+        await Promise.all(installPromises);
+
+        // Return initial result showing installations have been initiated
+        return {
+            success: true,
+            message: 'Client installations initiated successfully',
+            status: initialStatuses
+        };
+    }
+}

package/src/core/installers/CommandInstaller.ts

@@ -0,0 +1,185 @@
+import { RequirementConfig, RequirementStatus, OSType } from '../types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+import { getOSType, refreshPathEnv } from '../../utils/osUtils.js';
+import { Logger } from '../../utils/logger.js';
+
+/**
+ * Mapping of command names to their package IDs on different platforms
+ */
+interface CommandMapping {
+    windows: string;
+    macos: string;
+}
+
+/**
+ * Installer implementation for command-line tools
+ */
+export class CommandInstaller extends BaseInstaller {
+    /**
+     * Mapping of command names to their package IDs
+     * This handles special cases where the command name differs from the package ID
+     */
+    private commandMappings: Record<string, CommandMapping> = {
+        'uv': { windows: 'astral-sh.uv', macos: 'uv' }
+        // Add more mappings as needed
+    };
+
+    /**
+     * Check if this installer can handle the given requirement type
+     * @param requirement The requirement to check
+     * @returns True if this installer can handle the requirement
+     */
+    canHandle(requirement: RequirementConfig): boolean {
+        return requirement.type === 'command';
+    }
+
+    /**
+     * Get the mapped package ID for a command
+     * @param commandName The command name to map
+     * @returns The mapped package ID
+     */
+    private getMappedPackageId(commandName: string): string {
+        const osType = getOSType();
+        const mapping = this.commandMappings[commandName];
+
+        if (mapping) {
+            return osType === OSType.Windows ? mapping.windows : mapping.macos;
+        }
+
+        // If no mapping exists, use the command name itself
+        return commandName;
+    }
+
+    /**
+     * Check if the command is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
+        try {
+            await refreshPathEnv();
+            const commandName = requirement.alias || requirement.name;
+            const osType = getOSType();
+            let commandResult;
+
+            if (osType === OSType.Windows) {
+                // Check if command exists on Windows
+                try {
+                    commandResult = await this.execPromise(`where ${commandName} 2>nul`);
+                } catch (error) {
+                    Logger.debug(`Error checking command existence: ${error}`);
+                    // On Windows, 'where' command returns non-zero exit code if the command is not found
+                    // We'll handle this as "command not found" rather than an error
+                    commandResult = { stdout: '', stderr: '' };
+                }
+            } else {
+                // Check if command exists on macOS/Linux
+                try {
+                    commandResult = await this.execPromise(`which ${commandName} 2>/dev/null`);
+                } catch (error) {
+                    Logger.debug(`Error checking command existence: ${error}`);
+                    // Similarly handle command not found on Unix systems
+                    commandResult = { stdout: '', stderr: '' };
+                }
+            }
+
+            // If the command exists, it will return a path or multiple paths
+            const installed = commandResult.stdout.trim().length > 0;
+
+            // Try to get version information if available
+            let version: string | undefined;
+            if (installed) {
+                try {
+                    const versionResult = await this.execPromise(`${commandName} --version`);
+                    if (versionResult.stdout) {
+                        // Extract version information - this is a simple approach that might need refinement
+                        const versionMatch = versionResult.stdout.match(/\d+\.\d+(\.\d+)?/);
+                        version = versionMatch ? versionMatch[0] : undefined;
+                    }
+                } catch (error) {
+                    Logger.debug(`Error checking command version: ${error}`);
+                    // Ignore errors from version check, consider it installed anyway
+                }
+            }
+
+            return {
+                name: requirement.name,
+                type: 'command',
+                installed,
+                version,
+                inProgress: false
+            };
+        } catch (error) {
+            Logger.error(`Error checking installation: ${error}`);
+            return {
+                name: requirement.name,
+                type: 'command',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+
+    /**
+     * Install the command
+     * @param requirement The requirement to install
+     * @returns The status of the installation
+     */
+    async install(requirement: RequirementConfig): Promise<RequirementStatus> {
+        try {
+            const status = await this.checkInstallation(requirement);
+            if (status.installed) {
+                return status;
+            }
+
+            const packageId = this.getMappedPackageId(requirement.name);
+            const osType = getOSType();
+            let installCommand: string;
+
+            if (osType === OSType.Windows) {
+                // Windows installation using winget
+                installCommand = `winget install --id ${packageId}`;
+                if (requirement.version && requirement.version !== 'latest') {
+                    installCommand += ` --version ${requirement.version}`;
+                }
+            } else if (osType === OSType.MacOS) {
+                // macOS installation using Homebrew
+                installCommand = `brew install ${packageId}`;
+                if (requirement.version && requirement.version !== 'latest') {
+                    installCommand += `@${requirement.version}`;
+                }
+            } else {
+                throw new Error(`Unsupported operating system for installing ${requirement.name}`);
+            }
+
+            // Execute the installation command
+            const { stderr } = await this.execPromise(installCommand);
+            if (stderr && stderr.toLowerCase().includes('error')) {
+                throw new Error(stderr);
+            }
+
+            // Check if installation was successful
+            const updatedStatus = await this.checkInstallation(requirement);
+            if (!updatedStatus.installed) {
+                throw new Error(`Failed to install ${requirement.name}`);
+            }
+
+            return {
+                name: requirement.name,
+                type: 'command',
+                installed: true,
+                version: updatedStatus.version || requirement.version,
+                inProgress: false
+            };
+        } catch (error) {
+            return {
+                name: requirement.name,
+                type: 'command',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+}

package/src/core/installers/GeneralInstaller.ts

@@ -0,0 +1,89 @@
+import { RequirementConfig, RequirementStatus } from '../types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+
+/**
+ * Installer implementation for general requirements (type 'other')
+ * This installer handles requirements that don't fit into specific package manager categories
+ */
+export class GeneralInstaller extends BaseInstaller {
+    /**
+     * Check if this installer can handle the given requirement type
+     * @param requirement The requirement to check
+     * @returns True if this installer can handle the requirement
+     */
+    canHandle(requirement: RequirementConfig): boolean {
+        return requirement.type === 'other';
+    }
+
+    /**
+     * Check if the requirement is already installed
+     * For general installers, we can't easily check if something is installed
+     * without specific knowledge of the requirement, so we always return false
+     * 
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
+        // For general installers, we can't easily check if something is installed
+        // So we'll always return not installed, and the actual installation will check
+        return {
+            name: requirement.name,
+            type: 'other',
+            installed: false,
+            inProgress: false
+        };
+    }
+
+    /**
+     * Install the general requirement
+     * For type 'other', this doesn't actually install anything, but downloads
+     * or locates the asset and returns the path for the caller to use
+     * 
+     * @param requirement The requirement to install
+     * @returns The status of the installation, including the install path in updateInfo
+     */
+    async install(requirement: RequirementConfig): Promise<RequirementStatus> {
+        try {
+            // For type 'other', a registry must be specified
+            if (!requirement.registry) {
+                throw new Error('Registry must be specified for requirement type "other"');
+            }
+
+            let installPath: string;
+
+            if (requirement.registry.githubRelease) {
+                const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                installPath = result.resolvedPath;
+            } else if (requirement.registry.artifacts) {
+                installPath = await this.handleArtifactsRegistry(requirement, requirement.registry.artifacts);
+            } else if (requirement.registry.local) {
+                installPath = await this.handleLocalRegistry(requirement, requirement.registry.local);
+            } else {
+                throw new Error('Invalid registry configuration');
+            }
+
+            // For general installer, we just return the path to the downloaded/located file
+            // The actual installation mechanism would depend on the specific requirement
+            return {
+                name: requirement.name,
+                type: 'other',
+                installed: true,
+                version: requirement.version,
+                inProgress: false,
+                // Store installation path in a way that it can be retrieved later if needed
+                updateInfo: {
+                    available: false,
+                    installPath
+                }
+            };
+        } catch (error) {
+            return {
+                name: requirement.name,
+                type: 'other',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+}