imcp 0.1.7 → 0.1.8-dev

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

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

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

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

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

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

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