imcp 0.1.5 → 0.1.6

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

@@ -0,0 +1,165 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
+import { Logger } from '../../../utils/logger.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+
+const execAsync = promisify(exec);
+
+interface ExtensionInfo {
+    name: string;
+    publisher: string;
+    version: string;
+}
+
+export class ExtensionInstaller {
+    /**
+     * Get VSCode path based on the OS type
+     */
+    private static async getVSCodePath(isInsiders: boolean): Promise<string | null> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            if (process.platform === 'win32') {
+                // Windows: Check command availability first
+                await execAsync(`where ${command}`);
+                return command;
+            } else if (process.platform === 'darwin') {
+                // macOS: Check in both system and user Applications
+                const appName = isInsiders ? 'Visual Studio Code - Insiders.app' : 'Visual Studio Code.app';
+                const systemPath = `/Applications/${appName}`;
+                const userPath = `${process.env.HOME}/Applications/${appName}`;
+
+                try {
+                    await execAsync(`test -d "${systemPath}"`);
+                    return systemPath;
+                } catch {
+                    try {
+                        await execAsync(`test -d "${userPath}"`);
+                        return userPath;
+                    } catch {
+                        return null;
+                    }
+                }
+            }
+            return command;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * List installed extensions for VSCode or VSCode Insiders
+     */
+    private static async listExtensions(isInsiders: boolean): Promise<ExtensionInfo[]> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            const { stdout } = await execAsync(`${command} --list-extensions --show-versions`);
+            return stdout.split('\n')
+                .filter(line => line.trim())
+                .map(line => {
+                    const [extension, version] = line.split('@');
+                    const [publisher, name] = extension.split('.');
+                    return { name, publisher, version: version || '' };
+                });
+        } catch (error) {
+            Logger.error(`Failed to list extensions for ${command}:`, error);
+            return [];
+        }
+    }
+
+    /**
+     * Check if an extension is installed and get its version
+     */
+    private static async checkExtension(extensionId: string, isInsiders: boolean): Promise<string | null> {
+        const extensions = await this.listExtensions(isInsiders);
+        const [publisher, name] = extensionId.split('.');
+        const extension = extensions.find(ext =>
+            ext.publisher.toLowerCase() === publisher.toLowerCase() &&
+            ext.name.toLowerCase() === name.toLowerCase()
+        );
+        return extension ? extension.version : null;
+    }
+
+    /**
+     * Install extension from marketplace
+     */
+    private static async installPublicExtension(extensionId: string, isInsiders: boolean): Promise<boolean> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            await execAsync(`${command} --install-extension ${extensionId}`);
+            return true;
+        } catch (error) {
+            Logger.error(`Failed to install extension ${extensionId}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Install extension from VSIX file
+     */
+    private static async installPrivateExtension(vsixPath: string, isInsiders: boolean): Promise<boolean> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            await execAsync(`${command} --install-extension "${vsixPath}"`);
+            return true;
+        } catch (error) {
+            Logger.error(`Failed to install extension from VSIX ${vsixPath}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Install extension for a specific client
+     */
+    public static async installExtension(clientName: string): Promise<boolean> {
+        const client = SUPPORTED_CLIENTS[clientName];
+        if (!client?.extension?.extensionId) {
+            Logger.error(`No extension configuration found for client ${clientName}`);
+            return false;
+        }
+
+        const { extensionId, leastVersion, repository, assetName, private: isPrivate } = client.extension;
+        let success = false;
+
+        // Check both VSCode and VSCode Insiders
+        for (const isInsiders of [false, true]) {
+            const vscodePath = await this.getVSCodePath(isInsiders);
+            if (!vscodePath) {
+                Logger.debug(`${isInsiders ? 'VSCode Insiders' : 'VSCode'} not found, skipping...`);
+                continue;
+            }
+
+            const currentVersion = await this.checkExtension(extensionId, isInsiders);
+
+            if (!currentVersion || (isPrivate && leastVersion && compareVersions(currentVersion, leastVersion) < 0)) {
+                // Extension not installed or needs update (for private extensions)
+                if (!isPrivate) {
+                    // Install public extension from marketplace
+                    success = await this.installPublicExtension(extensionId, isInsiders);
+                } else {
+                    // Install private extension from GitHub release using latest version
+                    try {
+                        if (!repository || !assetName) {
+                            throw new Error(`Missing repository or assetName for private extension ${extensionId}`);
+                        }
+                        const { resolvedPath } = await handleGitHubRelease(
+                            { name: extensionId, version: 'latest', type: 'extension' },
+                            { repository, assetName }
+                        );
+                        success = await this.installPrivateExtension(resolvedPath, isInsiders);
+                    } catch (error) {
+                        Logger.error(`Failed to install/update private extension ${extensionId}:`, error);
+                        continue;
+                    }
+                }
+            } else {
+                // Extension already installed and up to date
+                Logger.debug(`Extension ${extensionId} is already installed and up to date`);
+                success = true;
+            }
+        }
+
+        return success;
+    }
+}

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

@@ -0,0 +1,79 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+
+/**
+ * Github Copilot client installer implementation
+ * Handles installation of Github Copilot client including extension installation and settings configuration
+ */
+export class GithubCopilotInstaller extends BaseClientInstaller {
+    protected readonly clientName: string = 'GithubCopilot';
+
+
+    /**
+     * Initialize settings with GithubCopilot-specific structure
+     * Overrides base method to provide custom initialization
+     */
+    protected initializeSettings(settings: any): void {
+        if (!settings.mcp) {
+            settings.mcp = {
+                servers: {},
+                inputs: []
+            };
+        }
+
+        if (!settings.mcp.servers) {
+            settings.mcp.servers = {};
+        }
+    }
+
+    /**
+     * Handle stdio mode configuration for GithubCopilot
+     * Overrides base method to provide custom stdio configuration
+     */
+    protected async handleStdioMode(settings: any, serverName: string, finalConfig: any): Promise<void> {
+        if (finalConfig.args) {
+            finalConfig.args = finalConfig.args.map((arg: string) =>
+                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+            );
+        }
+        settings.mcp.servers[serverName] = {
+            command: finalConfig.command,
+            args: finalConfig.args,
+            env: finalConfig.env
+        };
+    }
+
+    /**
+     * Handle SSE mode configuration for GithubCopilot
+     * Overrides base method to provide custom SSE configuration
+     */
+    protected handleSseMode(settings: any, serverName: string, installConfig: any): void {
+        settings.mcp.servers[serverName] = {
+            type: 'sse',
+            url: installConfig.url
+        };
+    }
+
+    /**
+     * Set up Github Copilot client settings
+     * Updates VS Code settings with MCP server configuration
+     * Note: GithubCopilot uses a different settings structure compared to other clients
+     */
+    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') {
+            await this.handleStdioMode(settings, serverName, installConfig);
+        } else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}

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

@@ -0,0 +1,32 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+
+/**
+ * MSRooCode client installer implementation
+ */
+export class MSRooCodeInstaller extends BaseClientInstaller {
+    protected readonly clientName: string = 'MSRooCode';
+    /**
+     * Set up MSRooCode client settings
+     */
+    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);
+    }
+}

package/src/core/installers/index.ts

@@ -0,0 +1,11 @@
+// Export the interface
+export { RequirementInstaller } from './requirements/RequirementInstaller.js';
+export { ClientInstaller } from './clients/ClientInstaller.js';
+
+// Export all requirement installer implementations
+export { BaseInstaller } from './requirements/BaseInstaller.js';
+export { NpmInstaller } from './requirements/NpmInstaller.js';
+export { PipInstaller } from './requirements/PipInstaller.js';
+export { GeneralInstaller } from './requirements/GeneralInstaller.js';
+export { CommandInstaller } from './requirements/CommandInstaller.js';
+export { InstallerFactory, createInstallerFactory } from './requirements/InstallerFactory.js';

package/src/core/installers/requirements/BaseInstaller.ts

@@ -0,0 +1,85 @@
+import { RequirementConfig, RequirementStatus, RegistryConfig, ServerInstallOptions } from '../../metadatas/types.js';
+import path from 'path';
+import { SETTINGS_DIR } from '../../metadatas/constants.js';
+import { RequirementInstaller } from './RequirementInstaller.js';
+import { Logger } from '../../../utils/logger.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+
+/**
+ * Abstract base class with common functionality for all requirement installers
+ */
+export abstract class BaseInstaller implements RequirementInstaller {
+    protected execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>;
+    protected downloadsDir: string;
+
+    constructor(execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>) {
+        this.execPromise = execPromise;
+        this.downloadsDir = path.join(SETTINGS_DIR, 'downloads');
+    }
+
+    abstract canHandle(requirement: RequirementConfig): boolean;
+    abstract supportCheckUpdates(): boolean;
+    /**
+     * Install the requirement
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation
+     */
+    abstract install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Get the latest version available for the requirement.
+     * This method needs to be implemented by concrete installers.
+     * @param requirement The requirement to check.
+     * @param options Optional server install options.
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    abstract getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined>;
+
+
+    /**
+     * Check if updates are available for the requirement
+     * @param requirement The requirement to check
+     * @param currentStatus The current status of the requirement
+     * @param options Optional server install options.
+     * @returns The status of the requirement with update information
+     */
+    async checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        try {
+            // If requirement is not installed, no need to check for updates
+            if (!currentStatus.installed) {
+                return currentStatus;
+            }
+
+            // If the version doesn't contain "latest", no update check needed
+            if (!requirement.version.includes('latest')) {
+                return currentStatus;
+            }
+
+            const latestVersion = await this.getLatestVersion(requirement, options);
+
+            // If we found a latest version and it's different from current
+            if (latestVersion && latestVersion !== currentStatus.version) {
+                return {
+                    ...currentStatus,
+                    availableUpdate: {
+                        version: latestVersion,
+                        message: `Update available: ${currentStatus.version} → ${latestVersion}`
+                    },
+                    lastCheckTime: new Date().toISOString()
+                };
+            } else {
+                return {
+                    ...currentStatus,
+                    lastCheckTime: new Date().toISOString()
+                };
+            }
+
+        } catch (error) {
+            // Don't update status on error, just log it
+            Logger.log(`Error checking for updates for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            return currentStatus;
+        }
+    }
+}

package/src/core/installers/requirements/CommandInstaller.ts

@@ -0,0 +1,231 @@
+import { RequirementConfig, RequirementStatus, OSType, ServerInstallOptions } from '../../metadatas/types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+import { getOSType, refreshPathEnv } from '../../../utils/osUtils.js';
+import { Logger } from '../../../utils/logger.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.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 {
+
+    /**
+     * Constructor for the CommandInstaller
+     * @param execPromise Function to execute commands
+     */
+    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined> {
+        throw new Error('Method not implemented.');
+    }
+
+    /**
+     * 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';
+    }
+
+    supportCheckUpdates(): boolean {
+        return false;
+    }
+    /**
+     * 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
+     */
+    /**
+     * Install the command
+     * @param requirement The requirement to install
+     * @param options Optional install options
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @returns The status of the installation
+     */
+    async install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
+        const doInstall = async (): Promise<RequirementStatus> => {
+            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) {
+                installCommand = `winget install --id ${packageId}`;
+                if (requirement.version && requirement.version !== 'latest') {
+                    installCommand += ` --version ${requirement.version}`;
+                }
+            } else if (osType === OSType.MacOS) {
+                installCommand = `brew install ${packageId}`;
+                if (requirement.version && requirement.version !== 'latest') {
+                    installCommand += `@${requirement.version}`;
+                }
+            } else {
+                if (recorder) await recorder.recordStep('CommandInstaller:UnsupportedOS', 'failed', `Unsupported OS for ${requirement.name}`);
+                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
+            };
+        };
+
+        if (recorder) {
+            return recorder.recording(doInstall, {
+                stepName: RecordingConstants.STEP_COMMAND_INSTALLER_INSTALL,
+                inProgressMessage: `Installing command: ${requirement.name}`,
+                endMessage: (result) =>
+                    result.installed
+                        ? `Install completed for ${requirement.name}`
+                        : `Install failed for ${requirement.name}`,
+                onError: (error) => {
+                    return {
+                        result: {
+                            name: requirement.name,
+                            type: 'command',
+                            installed: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            inProgress: false,
+                        },
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                },
+            });
+        } else {
+            try {
+                return await doInstall();
+            } catch (error) {
+                return {
+                    name: requirement.name,
+                    type: 'command',
+                    installed: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    inProgress: false,
+                };
+            }
+        }
+    }
+}