imcp 0.1.7 → 0.1.8-dev

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

@@ -1,341 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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);
-    }
-}