imcp 0.0.19 → 0.1.2

package/dist/core/installers/BaseInstaller.js

@@ -1,253 +0,0 @@
-import path from 'path';
-import fs from 'fs/promises';
-import { SETTINGS_DIR } from '../constants.js';
-import { extractZipFile } from '../../utils/clientUtils.js';
-import { Logger } from '../../utils/logger.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}`
-                    },
-                    lastCheckTime: new Date().toISOString()
-                };
-            }
-            else {
-                return {
-                    ...currentStatus,
-                    lastCheckTime: new Date().toISOString()
-                };
-            }
-        }
-        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 || '';
-        const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
-        const latestTag = stdout.trim();
-        let latestVersion = latestTag;
-        const tagWithVPrefix = latestVersion.startsWith('v');
-        if (tagWithVPrefix)
-            latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
-        version = version.includes("latest") ? latestVersion : version;
-        if (assetsName) {
-            resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
-        }
-        if (assetName) {
-            resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
-        }
-        Logger.debug(`Downloading ${requirement.name} from GitHub release ${repository} version ${version}`);
-        Logger.debug(`ResolvedAssetsName} ${resolvedAssetName}; ResolvedAsetName} ${resolvedAssetName}`);
-        const pattern = resolvedAssetsName ? resolvedAssetsName : resolvedAssetName;
-        Logger.debug(`Resolved pattern: ${pattern}`);
-        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 ${tagWithVPrefix ? `v${version}` : 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, options) {
-        const pythonCmd = options?.settings?.pythonEnv || 'python';
-        const { stdout } = await this.execPromise(`${pythonCmd} -m 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

@@ -1,23 +0,0 @@
-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;
-    /**
-     * Check if a command is available on the system
-     * @param command The command to check
-     * @returns True if the command is available, false otherwise
-     */
-    private isCommandAvailable;
-    private installClient;
-    private processInstallation;
-    private installClientConfig;
-    private updateClineOrMSRooSettings;
-    private updateGithubCopilotSettings;
-    install(options: ServerInstallOptions): Promise<ServerOperationResult>;
-}