imcp 0.0.1

package/dist/core/installers/BaseInstaller.js

@@ -0,0 +1,247 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { SETTINGS_DIR } from '../constants.js';
+import { extractZipFile } from '../../utils/clientUtils.js';
+/**
+ * Abstract base class with common functionality for all requirement installers
+ */
+export class BaseInstaller {
+    execPromise;
+    downloadsDir;
+    constructor(execPromise) {
+        this.execPromise = execPromise;
+        this.downloadsDir = path.join(SETTINGS_DIR, 'downloads');
+    }
+    /**
+     * Check if updates are available for the requirement
+     * @param requirement The requirement to check
+     * @param currentStatus The current status of the requirement
+     * @returns The status of the requirement with update information
+     */
+    async checkForUpdates(requirement, currentStatus) {
+        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;
+            }
+            let latestVersion;
+            // Check based on registry type
+            if (requirement.registry?.githubRelease) {
+                latestVersion = await this.getGitHubLatestVersion(requirement.registry.githubRelease.repository);
+            }
+            else {
+                // Use common practice based on requirement type
+                switch (requirement.type) {
+                    case 'npm':
+                        latestVersion = await this.getNpmLatestVersion(requirement.name);
+                        break;
+                    case 'pip':
+                        latestVersion = await this.getPipLatestVersion(requirement.name);
+                        break;
+                    // Add other types as needed
+                }
+            }
+            // 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}`,
+                        checkTime: new Date().toISOString()
+                    }
+                };
+            }
+            return currentStatus;
+        }
+        catch (error) {
+            // Don't update status on error, just log it
+            console.warn(`Error checking for updates for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            return currentStatus;
+        }
+    }
+    /**
+     * Helper method to ensure downloads directory exists
+     */
+    async ensureDownloadsDir() {
+        await fs.mkdir(this.downloadsDir, { recursive: true });
+    }
+    /**
+     * Helper to handle GitHub release downloads
+     * @param requirement The requirement configuration
+     * @param registry The GitHub release registry configuration
+     * @returns The path to the downloaded file
+     */
+    async handleGitHubRelease(requirement, registry) {
+        if (!registry) {
+            throw new Error('GitHub release registry configuration is required');
+        }
+        await this.ensureDownloadsDir();
+        const { repository, assetsName, assetName } = registry;
+        if (!repository) {
+            throw new Error('GitHub repository is required for GitHub release downloads');
+        }
+        let version = requirement.version;
+        let resolvedAssetName = assetName || '';
+        let resolvedAssetsName = assetsName || '';
+        // Handle latest version detection
+        if (version.includes('${latest}') || version === 'latest') {
+            const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+            const latestTag = stdout.trim();
+            let latestVersion = latestTag;
+            if (latestVersion.startsWith('v') && version.startsWith('v')) {
+                latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
+                // Replace ${latest} in version and asset names
+                version = version.replace('${latest}', latestVersion);
+                if (assetsName) {
+                    resolvedAssetsName = assetsName.replace('${latest}', latestVersion);
+                }
+                if (assetName) {
+                    resolvedAssetName = assetName.replace('${latest}', latestVersion);
+                }
+            }
+        }
+        const pattern = resolvedAssetsName ? resolvedAssetsName : resolvedAssetName;
+        if (!pattern) {
+            throw new Error('Either assetsName or assetName must be specified for GitHub release downloads');
+        }
+        // Download the release asset
+        const downloadPath = path.join(this.downloadsDir, path.basename(pattern));
+        if (!await this.fileExists(downloadPath)) {
+            await this.execPromise(`gh release download ${version} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
+        }
+        // Handle zip file extraction if the downloaded file is a zip
+        if (downloadPath.endsWith('.zip')) {
+            const extractDir = path.join(this.downloadsDir, path.basename(pattern, '.zip'));
+            await fs.mkdir(extractDir, { recursive: true });
+            // Extract the zip file
+            await extractZipFile(downloadPath, { dir: extractDir });
+            let assetPath = '';
+            // If resolvedAssetName is specified, look for it in the extracted directory
+            if (resolvedAssetName) {
+                assetPath = path.join(extractDir, resolvedAssetName);
+                try {
+                    await fs.access(assetPath);
+                    return { resolvedVersion: version, resolvedPath: assetPath };
+                }
+                catch (error) {
+                    throw new Error(`Asset ${resolvedAssetName} not found in extracted directory ${extractDir}`);
+                }
+            }
+            else {
+                assetPath = path.join(extractDir, path.basename(pattern, '.zip') + '.tgz');
+            }
+            // If no specific asset is required, return the extraction directory
+            return { resolvedVersion: version, resolvedPath: extractDir };
+        }
+        return { resolvedVersion: version, resolvedPath: downloadPath };
+    }
+    /**
+     * Helper to handle artifact registry downloads
+     * @param requirement The requirement configuration
+     * @param registry The artifacts registry configuration
+     * @returns The registry URL
+     */
+    async handleArtifactsRegistry(requirement, registry) {
+        if (!registry) {
+            throw new Error('Artifacts registry configuration is required');
+        }
+        const { registryUrl, assetName } = registry;
+        if (!registryUrl) {
+            throw new Error('Registry URL is required for artifacts downloads');
+        }
+        return registryUrl;
+    }
+    /**
+     * Helper to handle local path registry
+     * @param requirement The requirement configuration
+     * @param registry The local registry configuration
+     * @returns The local path or extracted asset path
+     */
+    async handleLocalRegistry(requirement, registry) {
+        if (!registry) {
+            throw new Error('Local registry configuration is required');
+        }
+        const { localPath, assetName } = registry;
+        if (!localPath) {
+            throw new Error('Local path is required for local registry');
+        }
+        // Verify the local path exists
+        try {
+            await fs.access(localPath);
+        }
+        catch (error) {
+            throw new Error(`Local path ${localPath} does not exist or is not accessible`);
+        }
+        // If the path is a zip file and assetName is specified, extract it
+        if (localPath.endsWith('.zip') && assetName) {
+            const extractDir = path.join(this.downloadsDir, path.basename(localPath, '.zip'));
+            await fs.mkdir(extractDir, { recursive: true });
+            // Extract the zip file
+            await extractZipFile(localPath, { dir: extractDir });
+            // Find the asset in the extracted directory
+            const assetPath = path.join(extractDir, assetName);
+            try {
+                await fs.access(assetPath);
+                return assetPath;
+            }
+            catch (error) {
+                throw new Error(`Asset ${assetName} not found in extracted directory ${extractDir}`);
+            }
+        }
+        return localPath;
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the latest version available for a GitHub repository
+     * @param repository The GitHub repository in format 'owner/repo'
+     * @returns The latest version or tag
+     */
+    async getGitHubLatestVersion(repository) {
+        try {
+            // Use GitHub CLI to get the latest release
+            const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+            const latestTag = stdout.trim();
+            // Remove 'v' prefix if present
+            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+        }
+        catch (error) {
+            // If gh command fails, try to get the latest tag
+            const { stdout } = await this.execPromise(`git ls-remote --tags --refs https://github.com/${repository}.git | sort -t '/' -k 3 -V | tail -n 1 | awk -F/ '{print $3}'`);
+            let latestTag = stdout.trim();
+            // Remove 'v' prefix if present
+            return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+        }
+    }
+    /**
+     * Get the latest version available for an NPM package
+     * @param packageName The name of the NPM package
+     * @returns The latest version
+     */
+    async getNpmLatestVersion(packageName) {
+        const { stdout } = await this.execPromise(`npm view ${packageName} version`);
+        return stdout.trim();
+    }
+    /**
+     * Get the latest version available for a pip package
+     * @param packageName The name of the pip package
+     * @returns The latest version
+     */
+    async getPipLatestVersion(packageName) {
+        const { stdout } = await this.execPromise(`pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
+        return stdout.trim();
+    }
+}
+//# sourceMappingURL=BaseInstaller.js.map

package/dist/core/installers/ClientInstaller.d.ts

@@ -0,0 +1,17 @@
+import { ServerOperationResult, ServerInstallOptions } from '../types.js';
+export declare class ClientInstaller {
+    private categoryName;
+    private serverName;
+    private clients;
+    private configProvider;
+    private operationStatuses;
+    constructor(categoryName: string, serverName: string, clients: string[]);
+    private generateOperationId;
+    private getNpmPath;
+    private installClient;
+    private processInstallation;
+    private installClientConfig;
+    private updateClineOrMSRooSettings;
+    private updateGithubCopilotSettings;
+    install(options: ServerInstallOptions): Promise<ServerOperationResult>;
+}

package/dist/core/installers/ClientInstaller.js

@@ -0,0 +1,307 @@
+import { ConfigurationProvider } from '../ConfigurationProvider.js';
+import { SUPPORTED_CLIENTS } from '../constants.js';
+import { resolveNpmModulePath, readJsonFile, writeJsonFile } from '../../utils/clientUtils.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+export class ClientInstaller {
+    categoryName;
+    serverName;
+    clients;
+    configProvider;
+    operationStatuses;
+    constructor(categoryName, serverName, clients) {
+        this.categoryName = categoryName;
+        this.serverName = serverName;
+        this.clients = clients;
+        this.configProvider = ConfigurationProvider.getInstance();
+        this.operationStatuses = new Map();
+    }
+    generateOperationId() {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    async getNpmPath() {
+        const execAsync = promisify(exec);
+        try {
+            // Execute the get-command npm command to find the npm path
+            const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
+            // Extract the directory from the full path (removing npm.cmd)
+            const npmPath = stdout.trim().replace(/\\npm\.cmd$/, '');
+            return npmPath;
+        }
+        catch (error) {
+            console.error('Error getting npm path:', error);
+            // Return a default path if the command fails
+            return 'C:\\Program Files\\nodejs';
+        }
+    }
+    async installClient(clientName, env) {
+        // Check if client is supported
+        if (!SUPPORTED_CLIENTS[clientName]) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unsupported client: ${clientName}`,
+                operationId: this.generateOperationId()
+            };
+        }
+        // Create initial operation status
+        const operationId = this.generateOperationId();
+        const initialStatus = {
+            status: 'pending',
+            type: 'install',
+            target: 'server',
+            message: `Initializing installation for client: ${clientName}`,
+            operationId: operationId
+        };
+        // Update server status with initial client installation status
+        await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, initialStatus);
+        // Start the asynchronous installation process without awaiting it
+        this.processInstallation(clientName, operationId, env);
+        // Return the initial status immediately
+        return initialStatus;
+    }
+    async processInstallation(clientName, operationId, env) {
+        try {
+            // Check requirements before installation
+            let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+            // If requirements are not ready, periodically check with timeout
+            if (!requirementsReady) {
+                const pendingStatus = {
+                    status: 'pending',
+                    type: 'install',
+                    target: 'server',
+                    message: `Waiting for requirements to be ready for client: ${clientName}`,
+                    operationId: operationId
+                };
+                // Update status to pending with reference to configProvider
+                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 in milliseconds
+                const intervalMs = 5 * 1000; // 5 seconds in milliseconds
+                while (!requirementsReady && (Date.now() - startTime) < timeoutMs) {
+                    // Wait for the interval
+                    await new Promise(resolve => setTimeout(resolve, intervalMs));
+                    // Check again
+                    requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
+                }
+                // If still not ready after timeout, update status as failed and exit
+                if (!requirementsReady) {
+                    const failedStatus = {
+                        status: 'failed',
+                        type: 'install',
+                        target: 'server',
+                        message: `Timed out waiting for requirements to be ready for client: ${clientName} after 5 minutes`,
+                        operationId: operationId
+                    };
+                    await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, failedStatus);
+                    return; // Exit the installation process
+                }
+            }
+            // If we've reached here, requirements are ready - update status to in-progress
+            const inProgressStatus = {
+                status: 'in-progress',
+                type: 'install',
+                target: 'server',
+                message: `Installing client: ${clientName}`,
+                operationId: operationId
+            };
+            await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, inProgressStatus);
+            // Get feed configuration for the server
+            const feedConfiguration = await this.configProvider.getFeedConfiguration(this.categoryName);
+            if (!feedConfiguration) {
+                const errorStatus = {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: `Failed to get feed configuration for category: ${this.categoryName}`,
+                    operationId: operationId
+                };
+                await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, errorStatus);
+                return;
+            }
+            // Find the server config in the feed configuration
+            const serverConfig = feedConfiguration.mcpServers.find(s => s.name === this.serverName);
+            if (!serverConfig) {
+                const errorStatus = {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: `Server ${this.serverName} not found in feed configuration`,
+                    operationId: operationId
+                };
+                await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, errorStatus);
+                return;
+            }
+            try {
+                // Install client-specific configuration
+                const result = await this.installClientConfig(clientName, env || {}, serverConfig, feedConfiguration);
+                const finalStatus = {
+                    status: result.success ? 'completed' : 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: result.message || `Installation for client ${clientName}: ${result.success ? 'successful' : 'failed'}`,
+                    operationId: operationId,
+                    error: result.success ? undefined : result.message
+                };
+                await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, finalStatus);
+            }
+            catch (error) {
+                const errorStatus = {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: `Failed to install client: ${clientName}. Error: ${error instanceof Error ? error.message : String(error)}`,
+                    operationId: operationId,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+                await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, errorStatus);
+            }
+        }
+        catch (error) {
+            const errorStatus = {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error in installation process for client: ${clientName}. Error: ${error instanceof Error ? error.message : String(error)}`,
+                operationId: operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+            await this.configProvider.updateServerOperationStatus(this.categoryName, this.serverName, clientName, errorStatus);
+        }
+    }
+    async installClientConfig(clientName, env, serverConfig, feedConfig) {
+        try {
+            if (!SUPPORTED_CLIENTS[clientName]) {
+                return { success: false, message: `Unsupported client: ${clientName}` };
+            }
+            const clientSettings = SUPPORTED_CLIENTS[clientName];
+            // Determine which setting path to use based on VS Code type (regular or insiders)
+            const settingPath = process.env.CODE_INSIDERS
+                ? clientSettings.codeInsiderSettingPath
+                : clientSettings.codeSettingPath;
+            if (!settingPath) {
+                return { success: false, message: `No settings path found for client: ${clientName}` };
+            }
+            // Clone the installation configuration to make modifications
+            const installConfig = JSON.parse(JSON.stringify(serverConfig.installation));
+            // Replace template variables in args
+            installConfig.args = installConfig.args.map((arg) => resolveNpmModulePath(arg));
+            // Add environment variables from options
+            installConfig.env = {};
+            if (serverConfig.installation.env) {
+                // Add default env variables from config
+                for (const [key, config] of Object.entries(serverConfig.installation.env)) {
+                    const envConfig = config; // Type assertion for dynamic access
+                    if (envConfig.Default) {
+                        installConfig.env[key] = envConfig.Default;
+                    }
+                }
+            }
+            // Override with provided env variables
+            if (env) {
+                Object.assign(installConfig.env, env);
+            }
+            // Update client-specific settings
+            if (clientName === 'MSRooCode' || clientName === 'Cline') {
+                await this.updateClineOrMSRooSettings(settingPath, this.serverName, installConfig, clientName);
+            }
+            else if (clientName === 'GithubCopilot') {
+                await this.updateGithubCopilotSettings(settingPath, this.serverName, installConfig);
+            }
+            else {
+                return {
+                    success: false,
+                    message: `Client ${clientName} is supported but no implementation exists for updating its settings`
+                };
+            }
+            return {
+                success: true,
+                message: `Successfully installed ${this.serverName} for client: ${clientName}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Error installing client ${clientName}: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    async updateClineOrMSRooSettings(settingPath, serverName, installConfig, clientName) {
+        // Read the Cline/MSRoo settings file
+        const settings = await readJsonFile(settingPath, true);
+        // Initialize mcpServers section if it doesn't exist
+        if (!settings.mcpServers) {
+            settings.mcpServers = {};
+        }
+        // Special handling for Windows when command is npx for Cline and MSROO clients
+        const serverConfig = { ...installConfig };
+        if (process.platform === 'win32' &&
+            serverConfig.command === 'npx' &&
+            (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
+            // Update command to cmd
+            serverConfig.command = 'cmd';
+            // Add /c and npx at the beginning of args
+            serverConfig.args = ['/c', 'npx', ...serverConfig.args];
+            // Add APPDATA environment variable pointing to npm directory
+            if (!serverConfig.env) {
+                serverConfig.env = {};
+            }
+            // Dynamically get npm path and set APPDATA to it
+            const npmPath = await this.getNpmPath();
+            serverConfig.env['APPDATA'] = npmPath;
+        }
+        // Add or update the server configuration
+        settings.mcpServers[serverName] = {
+            command: serverConfig.command,
+            args: serverConfig.args,
+            env: serverConfig.env,
+            autoApprove: [],
+            disabled: false,
+            alwaysAllow: []
+        };
+        // Write the updated settings back to the file
+        await writeJsonFile(settingPath, settings);
+    }
+    async updateGithubCopilotSettings(settingPath, serverName, installConfig) {
+        // Read the VS Code settings.json file
+        const settings = await readJsonFile(settingPath, true);
+        // Initialize the mcp section if it doesn't exist
+        if (!settings.mcp) {
+            settings.mcp = {
+                servers: {},
+                inputs: []
+            };
+        }
+        if (!settings.mcp.servers) {
+            settings.mcp.servers = {};
+        }
+        // Add or update the server configuration
+        settings.mcp.servers[serverName] = {
+            command: installConfig.command,
+            args: installConfig.args,
+            env: installConfig.env
+        };
+        // Write the updated settings back to the file
+        await writeJsonFile(settingPath, settings);
+    }
+    async install(options) {
+        const initialStatuses = [];
+        // Start installation for each client asynchronously and collect initial statuses
+        const installPromises = this.clients.map(async (clientName) => {
+            const initialStatus = await this.installClient(clientName, options.env || {});
+            initialStatuses.push(initialStatus);
+            return initialStatus;
+        });
+        // Wait for all initial statuses (but actual installation continues asynchronously)
+        await Promise.all(installPromises);
+        // Return initial result showing installations have been initiated
+        return {
+            success: true,
+            message: 'Client installations initiated successfully',
+            status: initialStatuses
+        };
+    }
+}
+//# sourceMappingURL=ClientInstaller.js.map

package/dist/core/installers/CommandInstaller.d.ts

@@ -0,0 +1,36 @@
+import { RequirementConfig, RequirementStatus } from '../types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+/**
+ * Installer implementation for command-line tools
+ */
+export declare class CommandInstaller extends BaseInstaller {
+    /**
+     * Mapping of command names to their package IDs
+     * This handles special cases where the command name differs from the package ID
+     */
+    private commandMappings;
+    /**
+     * 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;
+    /**
+     * Get the mapped package ID for a command
+     * @param commandName The command name to map
+     * @returns The mapped package ID
+     */
+    private getMappedPackageId;
+    /**
+     * Check if the command is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    /**
+     * Install the command
+     * @param requirement The requirement to install
+     * @returns The status of the installation
+     */
+    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+}