imcp 0.1.4 → 0.1.5

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/GeneralInstaller.ts

@@ -1,133 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
-import { BaseInstaller } from './BaseInstaller.js';
-import { handleGitHubRelease } from '../../../utils/githubUtils.js';
-import { handleArtifact } from '../../../utils/adoUtils.js';
-import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
-import * as RecordingConstants from '../../metadatas/recordingConstants.js';
-
-/**
- * Installer implementation for general requirements (type 'other')
- * This installer handles requirements that don't fit into specific package manager categories
- */
-export class GeneralInstaller extends BaseInstaller {
-
-    /**
-     * Constructor for the GeneralInstaller
-     * @param execPromise Function to execute commands
-     */
-    getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined> {
-        throw new Error('Method not implemented.');
-    }
-    /**
-     * Check if this installer can handle the given requirement type
-     * @param requirement The requirement to check
-     * @returns True if this installer can handle the requirement
-     */
-    canHandle(requirement: RequirementConfig): boolean {
-        return requirement.type === 'other';
-    }
-
-    supportCheckUpdates(): boolean {
-        return false;
-    }
-    /**
-     * Check if the requirement is already installed
-     * For general installers, we can't easily check if something is installed
-     * without specific knowledge of the requirement, so we always return false
-     * 
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
-        // For general installers, we can't easily check if something is installed
-        // So we'll always return not installed, and the actual installation will check
-        return {
-            name: requirement.name,
-            type: 'other',
-            installed: false,
-            inProgress: false
-        };
-    }
-
-    /**
-     * Install the general requirement
-     * For type 'other', this doesn't actually install anything, but downloads
-     * or locates the asset and returns the path for the caller to use
-     * 
-     * @param requirement The requirement to install
-     * @returns The status of the installation, including the install path in updateInfo
-     */
-    /**
-     * Install the general requirement
-     * For type 'other', this doesn't actually install anything, but downloads
-     * or locates the asset and returns the path for the caller to use
-     * @param requirement The requirement to install
-     * @param options Optional install options
-     * @param recorder Optional InstallOperationManager for recording steps
-     * @returns The status of the installation, including the install path in updateInfo
-     */
-    async install(requirement: RequirementConfig, recorder: InstallOperationManager, options?: ServerInstallOptions): Promise<RequirementStatus> {
-        const doInstall = async (): Promise<RequirementStatus> => {
-            // For type 'other', a registry must be specified
-            if (!requirement.registry) {
-                throw new Error('Registry must be specified for requirement type "other"');
-            }
-
-            let installPath: string;
-
-            if (requirement.registry.githubRelease) {
-                const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                installPath = result.resolvedPath;
-            } else if (requirement.registry.artifacts) {
-                await handleArtifact(requirement, requirement.registry.artifacts);
-            } else {
-                throw new Error('Invalid registry configuration');
-            }
-
-            // For general installer, we just return the path to the downloaded/located file
-            // The actual installation mechanism would depend on the specific requirement
-            return {
-                name: requirement.name,
-                type: 'other',
-                installed: true,
-                version: requirement.version,
-                inProgress: false,
-            };
-        };
-
-        if (recorder) {
-            return recorder.recording(doInstall, {
-                stepName: RecordingConstants.STEP_GENERAL_INSTALLER_INSTALL,
-                inProgressMessage: `Installing general requirement: ${requirement.name}`,
-                endMessage: (result) =>
-                    result.installed
-                        ? `Install completed for ${requirement.name}`
-                        : `Install failed for ${requirement.name}`,
-                onError: (error) => {
-                    return {
-                        result: {
-                            name: requirement.name,
-                            type: 'other',
-                            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: 'other',
-                    installed: false,
-                    error: error instanceof Error ? error.message : String(error),
-                    inProgress: false,
-                };
-            }
-        }
-    }
-}