imcp 0.0.4 → 0.0.5

package/dist/core/installers/clients/ExtensionInstaller.js

@@ -0,0 +1,149 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { Logger } from '../../../utils/logger.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+const execAsync = promisify(exec);
+export class ExtensionInstaller {
+    /**
+     * Get VSCode path based on the OS type
+     */
+    static async getVSCodePath(isInsiders) {
+        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
+     */
+    static async listExtensions(isInsiders) {
+        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
+     */
+    static async checkExtension(extensionId, isInsiders) {
+        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
+     */
+    static async installPublicExtension(extensionId, isInsiders) {
+        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
+     */
+    static async installPrivateExtension(vsixPath, isInsiders) {
+        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
+     */
+    static async installExtension(clientName) {
+        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 {
+                        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;
+    }
+}
+//# sourceMappingURL=ExtensionInstaller.js.map

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

@@ -1,6 +1,8 @@
-export { RequirementInstaller } from './RequirementInstaller.js';
-export { BaseInstaller } from './BaseInstaller.js';
-export { NpmInstaller } from './NpmInstaller.js';
-export { PipInstaller } from './PipInstaller.js';
-export { GeneralInstaller } from './GeneralInstaller.js';
-export { InstallerFactory, createInstallerFactory } from './InstallerFactory.js';
+export { RequirementInstaller } from './requirements/RequirementInstaller.js';
+export { ClientInstaller } from './clients/ClientInstaller.js';
+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/dist/core/installers/index.js

@@ -1,7 +1,9 @@
-// Export all installer implementations
-export { BaseInstaller } from './BaseInstaller.js';
-export { NpmInstaller } from './NpmInstaller.js';
-export { PipInstaller } from './PipInstaller.js';
-export { GeneralInstaller } from './GeneralInstaller.js';
-export { InstallerFactory, createInstallerFactory } from './InstallerFactory.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';
 //# sourceMappingURL=index.js.map

package/dist/core/installers/requirements/BaseInstaller.d.ts

@@ -0,0 +1,59 @@
+import { RequirementConfig, RequirementStatus, RegistryConfig, ServerInstallOptions } from '../../types.js';
+import { RequirementInstaller } from './RequirementInstaller.js';
+/**
+ * Abstract base class with common functionality for all requirement installers
+ */
+export declare 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;
+    }>);
+    abstract canHandle(requirement: RequirementConfig): boolean;
+    abstract supportCheckUpdates(): boolean;
+    abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * 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
+     */
+    checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
+    /**
+     * Helper to handle artifact registry downloads
+     * @param requirement The requirement configuration
+     * @param registry The artifacts registry configuration
+     * @returns The registry URL
+     */
+    protected handleArtifactsRegistry(requirement: RequirementConfig, registry: RegistryConfig['artifacts']): Promise<string>;
+    /**
+     * 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
+     */
+    protected handleLocalRegistry(requirement: RequirementConfig, registry: RegistryConfig['local']): Promise<string>;
+    /**
+     * Get the latest version available for a GitHub repository
+     * @param repository The GitHub repository in format 'owner/repo'
+     * @returns The latest version or tag
+     */
+    protected getGitHubLatestVersion(repository: string): Promise<string>;
+    /**
+     * Get the latest version available for an NPM package
+     * @param packageName The name of the NPM package
+     * @returns The latest version
+     */
+    protected getNpmLatestVersion(packageName: string): Promise<string>;
+    /**
+     * Get the latest version available for a pip package
+     * @param packageName The name of the pip package
+     * @returns The latest version
+     */
+    protected getPipLatestVersion(packageName: string, options?: ServerInstallOptions): Promise<string>;
+}

package/dist/core/installers/requirements/BaseInstaller.js

@@ -0,0 +1,168 @@
+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}`
+                    },
+                    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 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;
+    }
+    /**
+     * 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/requirements/CommandInstaller.d.ts

@@ -0,0 +1,37 @@
+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;
+    supportCheckUpdates(): 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>;
+}

package/dist/core/installers/requirements/CommandInstaller.js

@@ -0,0 +1,173 @@
+import { OSType } from '../../types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+import { getOSType, refreshPathEnv } from '../../../utils/osUtils.js';
+import { Logger } from '../../../utils/logger.js';
+/**
+ * Installer implementation for command-line tools
+ */
+export 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
+     */
+    commandMappings = {
+        '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) {
+        return requirement.type === 'command';
+    }
+    supportCheckUpdates() {
+        return false;
+    }
+    /**
+     * Get the mapped package ID for a command
+     * @param commandName The command name to map
+     * @returns The mapped package ID
+     */
+    getMappedPackageId(commandName) {
+        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) {
+        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;
+            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
+     */
+    async install(requirement) {
+        try {
+            const status = await this.checkInstallation(requirement);
+            if (status.installed) {
+                return status;
+            }
+            const packageId = this.getMappedPackageId(requirement.name);
+            const osType = getOSType();
+            let installCommand;
+            if (osType === OSType.Windows) {
+                // Windows installation using winget
+                installCommand = `winget install --id ${packageId}`;
+                if (requirement.version && requirement.version !== 'latest') {
+                    installCommand += ` --version ${requirement.version}`;
+                }
+            }
+            else if (osType === OSType.MacOS) {
+                // macOS installation using Homebrew
+                installCommand = `brew install ${packageId}`;
+                if (requirement.version && requirement.version !== 'latest') {
+                    installCommand += `@${requirement.version}`;
+                }
+            }
+            else {
+                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
+            };
+        }
+        catch (error) {
+            return {
+                name: requirement.name,
+                type: 'command',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+}
+//# sourceMappingURL=CommandInstaller.js.map

package/dist/core/installers/requirements/GeneralInstaller.d.ts

@@ -0,0 +1,33 @@
+import { RequirementConfig, RequirementStatus } from '../../types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+/**
+ * Installer implementation for general requirements (type 'other')
+ * This installer handles requirements that don't fit into specific package manager categories
+ */
+export declare class GeneralInstaller extends BaseInstaller {
+    /**
+     * 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;
+    supportCheckUpdates(): boolean;
+    /**
+     * 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
+     */
+    checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    /**
+     * 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(requirement: RequirementConfig): Promise<RequirementStatus>;
+}