imcp 0.1.5 → 0.1.6

package/src/core/installers/clients/BaseClientInstaller.ts

@@ -0,0 +1,341 @@
+import { Logger } from '../../../utils/logger.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { isCommandAvailable, getNpmExecutablePath } from '../../../utils/osUtils.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
+import {
+    OperationStatus,
+    McpConfig,
+    ServerInstallOptions,
+} from '../../metadatas/types.js';
+import {
+    MACRO_EXPRESSIONS,
+    MacroResolverFunctions
+} from '../../../utils/macroExpressionUtils.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Base class for client installers with shared functionality
+ */
+export abstract class BaseClientInstaller {
+    protected abstract readonly clientName: string;
+    /**
+     * Generate a unique operation ID for tracking installations
+     */
+    protected generateOperationId(): string {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Set up installation configuration with environment variables and arguments
+     * Handles Python environment configuration if specified
+     */
+    protected async setupInstallConfig(
+        serverConfig: McpConfig,
+        options: ServerInstallOptions
+    ): Promise<any> {
+        const finalConfig: any = { ...serverConfig.installation };
+        finalConfig.mode = serverConfig.mode;
+
+        // Handle command line arguments
+        if (options.args && options.args.length > 0) {
+            Logger.debug(`Using args from ServerInstallOptions: ${options.args.join(' ')}`);
+            finalConfig.args = options.args;
+        }
+
+        // Handle environment variables
+        const baseEnv = finalConfig.env || {};
+        const defaultEnv: Record<string, string> = {};
+        for (const [key, config] of Object.entries(baseEnv)) {
+            const envConfig = config as any;
+            if (envConfig.Default) {
+                defaultEnv[key] = envConfig.Default;
+            }
+        }
+        finalConfig.env = { ...defaultEnv, ...(options.env || {}) };
+
+        // Handle macro expressions
+        await this._resolveConfigMacros(finalConfig, options);
+
+        Logger.debug(`Final installation config: ${JSON.stringify(finalConfig)}`);
+        return finalConfig;
+    }
+
+    /**
+     * Resolves and replaces known macro expressions (e.g., ${PYTHON_PACKAGE}, ${NPMPATH}, ${BROWSER_PATH})
+     * in the provided configuration object's 'args' and 'env' properties.
+     * This method directly mutates the finalConfig object.
+     * @param finalConfig The configuration object to modify.
+     * @param options Server installation options which may contain settings like pythonEnv or npmPath.
+     */
+    private async _resolveConfigMacros(
+        finalConfig: any,
+        options: ServerInstallOptions
+    ): Promise<void> {
+        for (const macro of Object.values(MACRO_EXPRESSIONS)) {
+            const isMacroInArgs = finalConfig.args?.some((arg: string) => typeof arg === 'string' && arg.includes(macro));
+            const isMacroInEnv = Object.values(finalConfig.env || {}).some(value => typeof value === 'string' && value.includes(macro));
+
+            if (!isMacroInArgs && !isMacroInEnv) {
+                Logger.debug(`Macro ${macro} not found in args or env, skipping resolution.`);
+                continue;
+            }
+
+            const resolver = MacroResolverFunctions[macro];
+            if (resolver) {
+                const resolvedValue = await resolver(finalConfig, options);
+                if (resolvedValue !== undefined) {
+                    // Replace in args
+                    if (finalConfig.args) {
+                        const originalArgsString = finalConfig.args.join(' ');
+                        finalConfig.args = finalConfig.args.map((arg: string) =>
+                            typeof arg === 'string' && arg.includes(macro)
+                                ? arg.replace(new RegExp(macro.replace(/[${}]/g, '\\$&'), 'g'), resolvedValue)
+                                : arg
+                        );
+                        if (finalConfig.args.join(' ') !== originalArgsString) {
+                            Logger.debug(`Args after ${macro} ('${resolvedValue}') replacement: ${finalConfig.args.join(' ')}`);
+                        }
+                    }
+                    // Replace in env
+                    if (finalConfig.env) {
+                        const originalEnvJson = JSON.stringify(finalConfig.env);
+                        for (const key in finalConfig.env) {
+                            if (typeof finalConfig.env[key] === 'string' && (finalConfig.env[key] as string).includes(macro)) {
+                                finalConfig.env[key] = (finalConfig.env[key] as string).replace(new RegExp(macro.replace(/[${}]/g, '\\$&'), 'g'), resolvedValue);
+                            }
+                        }
+                        if (JSON.stringify(finalConfig.env) !== originalEnvJson) {
+                            Logger.debug(`Env after ${macro} ('${resolvedValue}') replacement: ${JSON.stringify(finalConfig.env)}`);
+                        }
+                    }
+                } else {
+                    Logger.debug(`Could not resolve value for macro: ${macro}. It will not be replaced.`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handle NPX commands for Windows platform
+     */
+    protected async handleWindowsNpx(config: any): Promise<any> {
+        if (process.platform === 'win32' && config.command === 'npx') {
+            const npmPath = await getNpmExecutablePath();
+            return {
+                ...config,
+                command: 'cmd',
+                args: ['/c', 'npx', ...config.args],
+                env: {
+                    ...config.env,
+                    'APPDATA': npmPath
+                }
+            };
+        }
+        return config;
+    }
+
+    /**
+     * Initialize settings object with client-specific structure
+     * Override in child classes to provide custom initialization
+     */
+    protected initializeSettings(settings: any): void {
+        if (!settings.mcpServers) {
+            settings.mcpServers = {};
+        }
+    }
+
+    /**
+     * Handle stdio mode configuration
+     * Override in child classes to provide custom stdio configuration
+     */
+    protected async handleStdioMode(settings: any, serverName: string, finalConfig: any): Promise<void> {
+        // Convert backslashes to forward slashes in args
+        if (finalConfig.args) {
+            finalConfig.args = finalConfig.args.map((arg: string) =>
+                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+            );
+        }
+        settings.mcpServers[serverName] = {
+            command: finalConfig.command,
+            args: finalConfig.args,
+            env: finalConfig.env,
+            autoApprove: [],
+            disabled: false,
+            alwaysAllow: []
+        };
+    }
+
+    /**
+     * Handle SSE mode configuration
+     * Override in child classes to provide custom SSE configuration
+     */
+    protected handleSseMode(settings: any, serverName: string, installConfig: any): void {
+        settings.mcpServers[serverName] = {
+            type: 'sse',
+            url: installConfig.url
+        };
+    }
+
+    /**
+     * Checks if VS Code or VS Code Insiders is installed and installs the client extension.
+     * @param operationId The operation ID for tracking.
+     * @returns An OperationStatus object if checks fail or installation fails, otherwise undefined.
+     */
+    protected async checkVSCodeAndInstallExtension(operationId: string): Promise<OperationStatus | undefined> {
+        // Check if VS Code or VS Code Insiders is installed
+        const isVSCodeInstalled = await isCommandAvailable('code');
+        const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+
+        if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: 'Failed to install as neither VS Code nor VS Code Insiders are installed on this system. Please run `code` or `code-insiders` to make sure they are installed. Relaunch imcp after installation.',
+                operationId
+            };
+        }
+
+        // Install extension
+        const extensionResult = await ExtensionInstaller.installExtension(this.clientName);
+        if (!extensionResult) {
+            Logger.debug(`Failed to install ${this.clientName} extension`);
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Failed to install ${this.clientName} extension`,
+                operationId
+            };
+        }
+        return undefined;
+    }
+
+    /**
+     * Update VS Code settings for both VS Code and VS Code Insiders if installed
+     * @param serverName The name of the server to configure
+     * @param installConfig The installation configuration
+     * @returns Array of results indicating success/failure for each VS Code variant
+     */
+    protected async updateVSCodeSettings(serverName: string, installConfig: any): Promise<Array<{ success: boolean; path: string; error?: string }>> {
+        const results: Array<{ success: boolean; path: string; error?: string }> = [];
+        const isVSCodeInstalled = await isCommandAvailable('code');
+        const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+
+        // Update settings for VS Code if installed
+        if (isVSCodeInstalled) {
+            try {
+                const settingPath = SUPPORTED_CLIENTS[this.clientName].codeSettingPath;
+                await this.setupClientSettings(settingPath, serverName, installConfig);
+                results.push({ success: true, path: settingPath });
+            } catch (error) {
+                results.push({
+                    success: false,
+                    path: SUPPORTED_CLIENTS[this.clientName].codeSettingPath,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+
+        // Update settings for VS Code Insiders if installed
+        if (isVSCodeInsidersInstalled) {
+            try {
+                const settingPath = SUPPORTED_CLIENTS[this.clientName].codeInsiderSettingPath;
+                await this.setupClientSettings(settingPath, serverName, installConfig);
+                results.push({ success: true, path: settingPath });
+            } catch (error) {
+                results.push({
+                    success: false,
+                    path: SUPPORTED_CLIENTS[this.clientName].codeInsiderSettingPath,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Install the client
+     * @param serverConfig Server configuration
+     * @param options Installation options including environment variables and arguments
+     */
+    async install(serverConfig: McpConfig, options: ServerInstallOptions, categoryName?: string): Promise<OperationStatus> {
+        const operationId = this.generateOperationId();
+
+        const recorder = InstallOperationManager.getInstance(categoryName || serverConfig.name, serverConfig.name);
+        return await recorder.recording(
+            async () => {
+                await recorder.recording(
+                    () => this.checkVSCodeAndInstallExtension(operationId), {
+                    stepName: RecordingConstants.STEP_CHECK_VSCODE_AND_INSTALL_EXTENSION,
+                    onResult: (result) => result?.status !== 'failed'
+                }
+                )
+
+                const installConfig = await recorder.recording(
+                    () => this.setupInstallConfig(serverConfig, options), {
+                    stepName: RecordingConstants.STEP_SETUP_INSTALLATION_CONFIG
+                });
+
+                if (serverConfig.mode) {
+                    installConfig.mode = serverConfig.mode;
+                }
+
+                const results = await recorder.recording(
+                    () => this.updateVSCodeSettings(serverConfig.name, installConfig), {
+                    stepName: RecordingConstants.STEP_UPDATE_VSCODE_SETTINGS,
+                    onResult: (result) => result?.some(r => r.success)
+                }
+                );
+
+                // Determine overall success
+                const anySuccess = results.some(r => r.success);
+                const successPaths = results.filter(r => r.success).map(r => r.path);
+                const errors = results.filter(r => !r.success).map(r => r.error);
+
+                const finalMessage = anySuccess
+                    ? `Successfully installed ${this.clientName} client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install ${this.clientName} client. Errors: ${errors.join('; ')}`;
+
+                return {
+                    status: anySuccess ? 'completed' : 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: finalMessage,
+                    operationId,
+                    error: anySuccess ? undefined : errors.join('; ')
+                };
+            },
+            {
+                stepName: RecordingConstants.STEP_INSTALLATION,
+                onResult: (result) => result?.status !== 'failed',
+                endMessage: (result) => (result as OperationStatus)?.message,
+                onError: (error) => {
+                    const errorMsg = `Unexpected error installing ${this.clientName} client: ${error instanceof Error ? error.message : String(error)}`;
+                    return {
+                        result: {
+                            status: 'failed',
+                            type: 'install',
+                            target: 'server',
+                            message: errorMsg,
+                            operationId,
+                            error: error instanceof Error ? error.message : String(error)
+                        }, message: errorMsg
+                    };
+                }
+            }
+        );
+
+    }
+
+    /**
+     * Abstract method that must be implemented by client-specific installers
+     */
+    abstract setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void>;
+}

package/src/core/installers/clients/ClientInstaller.ts

@@ -0,0 +1,222 @@
+import { ConfigurationProvider } from '../../loaders/ConfigurationProvider.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
+import {
+    ServerOperationResult,
+    OperationStatus,
+    ServerInstallOptions,
+    McpConfig,
+    RequirementStatus
+} from '../../metadatas/types.js';
+import { Logger } from '../../../utils/logger.js';
+import { ClientInstallerFactory } from './ClientInstallerFactory.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import { stat } from 'fs';
+
+/**
+ * Main client installer class that orchestrates client installation process
+ * Handles requirements checking and delegates to specific client installers
+ */
+export class ClientInstaller {
+    private configProvider: ConfigurationProvider;
+
+    constructor(
+        private categoryName: string,
+        private serverName: string,
+        private clients: string[]
+    ) {
+        this.configProvider = ConfigurationProvider.getInstance();
+    }
+
+    /**
+     * Install all specified clients
+     */
+    async install(options: ServerInstallOptions): Promise<ServerOperationResult> {
+        const initialStatuses: OperationStatus[] = [];
+
+        // Start installation for each client asynchronously
+        const installPromises = this.clients.map(async (clientName) => {
+            const status = await this.installClient(clientName, options);
+            initialStatuses.push(status);
+            return status;
+        });
+
+        // Wait for all installations to complete
+        await Promise.all(installPromises);
+
+        // Return result
+        return {
+            success: true,
+            message: 'Client installations completed',
+            status: initialStatuses
+        };
+    }
+
+    /**
+     * Install client with requirements checking
+     */
+    private async installClient(clientName: string, options: ServerInstallOptions): Promise<OperationStatus> {
+        const operationId = this.generateOperationId();
+
+        // Check if client is supported
+        if (!ClientInstallerFactory.isClientSupported(clientName)) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unsupported client: ${clientName}`,
+                operationId
+            };
+        }
+
+        // Create initial operation status
+        const initialStatus: OperationStatus = {
+            status: 'pending',
+            type: 'install',
+            target: 'server',
+            message: `Initializing installation for client: ${clientName}`,
+            operationId
+        };
+
+        // Async installation process
+        this.processInstallation(clientName, operationId, options)
+            .then((status) => {
+                if (status.status === 'completed' || status.status === 'failed') {
+                    InstallOperationManager
+                        .getInstance(this.categoryName, this.serverName)
+                        .markOverallStatus(status.status)
+                }
+
+                this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    status
+                );
+            })
+            .catch((error) => {
+                this.configProvider.updateServerOperationStatus(
+                    this.categoryName,
+                    this.serverName,
+                    clientName,
+                    {
+                        status: 'failed',
+                        type: 'install',
+                        target: 'server',
+                        message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`,
+                        operationId,
+                        error: error instanceof Error ? error.message : String(error)
+                    }
+                );
+                Logger.error(`Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`);
+                InstallOperationManager
+                    .getInstance(this.categoryName, this.serverName)
+                    .markOverallStatus('failed', error)
+            });
+
+        // Update server status with initial client installation status
+        await this.configProvider.updateServerOperationStatus(
+            this.categoryName,
+            this.serverName,
+            clientName,
+            initialStatus
+        );
+        return initialStatus;
+    }
+
+    private async processInstallation(clientName: string, operationId: string, options: ServerInstallOptions): Promise<OperationStatus> {
+        const requirementsReady = await this.checkRequirements(operationId, clientName, options);
+        if (!requirementsReady) {
+            const failedStatus: OperationStatus = {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Requirements not ready for client: ${clientName} after timeout`,
+                operationId
+            };
+            return failedStatus;
+        }
+
+        // Create client-specific installer
+        const installer = ClientInstallerFactory.getInstaller(clientName);
+
+        if (!installer) {
+            throw new Error(`Failed to create installer for client: ${clientName}`);
+        }
+
+        const serverConfig = await this.configProvider.getServerMcpConfig(this.categoryName, this.serverName);
+        if (!serverConfig) {
+            throw new Error(`Server configuration not found for category: ${this.categoryName}, server: ${this.serverName}`);
+        }
+
+        // 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
+        );
+        // Install client
+        return await installer.install(serverConfig, options, this.categoryName);
+    }
+
+    /**
+ * Generate a unique operation ID for tracking installations
+ */
+    private generateOperationId(): string {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Check if server requirements are ready
+     * Waits for requirements to be ready with timeout
+     */
+    private async checkRequirements(operationId: string, clientName: string, options: ServerInstallOptions): Promise<boolean> {
+        let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+
+        if (!requirementsReady) {
+            const pendingStatus: OperationStatus = {
+                status: 'pending',
+                type: 'install',
+                target: 'server',
+                message: `Waiting for requirements to be ready for client: ${clientName}`,
+                operationId
+            };
+
+            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
+            const intervalMs = 5 * 1000; // 5 seconds
+
+            while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
+                await new Promise(resolve => setTimeout(resolve, intervalMs));
+                requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+            }
+        }
+
+        var requirementsStatus: RequirementStatus[] = await this.configProvider.GetServerRequirementStatus(this.categoryName, this.serverName);
+
+        // Find first non-empty npmPath from requirements status
+        const npmPathRequirement = requirementsStatus.find(status => status.npmPath && status.npmPath.length > 0);
+        if (npmPathRequirement && npmPathRequirement.npmPath) {
+            options.settings = options.settings || {};
+            options.settings.npmPath = npmPathRequirement.npmPath;
+        }
+
+        return requirementsReady;
+    }
+}

package/src/core/installers/clients/ClientInstallerFactory.ts

@@ -0,0 +1,43 @@
+import { MSRooCodeInstaller } from './MSRooCodeInstaller.js';
+import { ClineInstaller } from './ClineInstaller.js';
+import { GithubCopilotInstaller } from './GithubCopilotInstaller.js';
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
+
+/**
+ * Factory for creating client-specific installers
+ * Handles creation of appropriate installer based on client type
+ */
+export class ClientInstallerFactory {
+    private static readonly installerMap: Record<string, new () => BaseClientInstaller> = {
+        [Object.keys(SUPPORTED_CLIENTS)[0]]: MSRooCodeInstaller,
+        [Object.keys(SUPPORTED_CLIENTS)[1]]: ClineInstaller,
+        [Object.keys(SUPPORTED_CLIENTS)[2]]: GithubCopilotInstaller
+    };
+
+    /**
+     * Get a client installer instance based on client type
+     * @param clientName Name of the client to get installer for
+     * @returns Client-specific installer instance or undefined if client not supported
+     */
+    static getInstaller(
+        clientName: string
+    ): BaseClientInstaller | undefined {
+        // Check if client is supported
+        if (!SUPPORTED_CLIENTS[clientName]) {
+            return undefined;
+        }
+
+        const InstallerClass = this.installerMap[clientName as keyof typeof this.installerMap];
+        return InstallerClass ? new InstallerClass() : undefined;
+    }
+
+    /**
+     * Check if a client is supported
+     * @param clientName Name of the client to check
+     * @returns True if client is supported, false otherwise
+     */
+    static isClientSupported(clientName: string): boolean {
+        return !!SUPPORTED_CLIENTS[clientName];
+    }
+}

package/src/core/installers/clients/ClineInstaller.ts

@@ -0,0 +1,35 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+
+/**
+ * Cline client installer implementation
+ * Handles installation of Cline client including extension installation and settings configuration
+ */
+export class ClineInstaller extends BaseClientInstaller {
+    protected readonly clientName: string = 'Cline';
+
+    /**
+     * Set up Cline client settings
+     * Updates VS Code settings with MCP server configuration
+     */
+    async setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void> {
+        // Read existing settings
+        const settings = await readJsonFile(settingPath, true);
+
+        // Initialize settings with client-specific structure
+        this.initializeSettings(settings);
+
+        // Handle different modes
+        if (installConfig.mode === 'stdio') {
+            // Process config for Windows NPX if needed
+            const finalConfig = await this.handleWindowsNpx(installConfig);
+
+            await this.handleStdioMode(settings, serverName, finalConfig);
+        } else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}