imcp 0.1.7 → 0.1.8-dev

package/dist/core/installers/CommandInstaller.js

@@ -1,173 +0,0 @@
-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/GeneralInstaller.d.ts

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

package/dist/core/installers/GeneralInstaller.js

@@ -1,85 +0,0 @@
-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 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) {
-        return requirement.type === 'other';
-    }
-    supportCheckUpdates() {
-        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) {
-        // 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
-     */
-    async install(requirement) {
-        try {
-            // For type 'other', a registry must be specified
-            if (!requirement.registry) {
-                throw new Error('Registry must be specified for requirement type "other"');
-            }
-            let installPath;
-            if (requirement.registry.githubRelease) {
-                const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                installPath = result.resolvedPath;
-            }
-            else if (requirement.registry.artifacts) {
-                installPath = await this.handleArtifactsRegistry(requirement, requirement.registry.artifacts);
-            }
-            else if (requirement.registry.local) {
-                installPath = await this.handleLocalRegistry(requirement, requirement.registry.local);
-            }
-            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,
-            };
-        }
-        catch (error) {
-            return {
-                name: requirement.name,
-                type: 'other',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
-        }
-    }
-}
-//# sourceMappingURL=GeneralInstaller.js.map

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

@@ -1,54 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../types.js';
-import { RequirementInstaller } from './RequirementInstaller.js';
-import { exec } from 'child_process';
-/**
- * Factory for creating the appropriate installer for a requirement
- */
-export declare class InstallerFactory {
-    private installers;
-    private readonly execPromise;
-    /**
-     * Create a new InstallerFactory
-     * @param execPromise Function to execute commands
-     */
-    constructor(execPromise: (command: string) => Promise<{
-        stdout: string;
-        stderr: string;
-    }>);
-    /**
-     * Register default installers for npm, pip, and general requirements
-     * @private
-     */
-    private registerDefaultInstallers;
-    /**
-     * Register a custom installer
-     * @param installer The installer to register
-     */
-    registerInstaller(installer: RequirementInstaller): void;
-    /**
-     * Get the appropriate installer for a requirement
-     * @param requirement The requirement to get an installer for
-     * @returns The appropriate installer, or undefined if none found
-     */
-    getInstaller(requirement: RequirementConfig): RequirementInstaller | undefined;
-    /**
-     * Install a requirement using the appropriate installer
-     * @param requirement The requirement to install
-     * @param options Installation options including python environment
-     * @returns The installation status
-     */
-    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    /**
-      * Check the installation status of a requirement
-      * @param requirement The requirement to check
-      * @param options Installation options including python environment
-      * @returns The installation status
-      */
-    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-}
-/**
- * Create a new InstallerFactory with default settings
- * @param execPromise Optional function to execute commands
- * @returns A new InstallerFactory
- */
-export declare const createInstallerFactory: (execPromise?: typeof exec.__promisify__) => InstallerFactory;

package/dist/core/installers/InstallerFactory.js

@@ -1,97 +0,0 @@
-import { NpmInstaller } from './NpmInstaller.js';
-import { PipInstaller } from './PipInstaller.js';
-import { CommandInstaller } from './CommandInstaller.js';
-import { GeneralInstaller } from './GeneralInstaller.js';
-import { exec } from 'child_process';
-import util from 'util';
-/**
- * Factory for creating the appropriate installer for a requirement
- */
-export class InstallerFactory {
-    installers = [];
-    execPromise;
-    /**
-     * Create a new InstallerFactory
-     * @param execPromise Function to execute commands
-     */
-    constructor(execPromise) {
-        this.execPromise = execPromise;
-        this.registerDefaultInstallers();
-    }
-    /**
-     * Register default installers for npm, pip, and general requirements
-     * @private
-     */
-    registerDefaultInstallers() {
-        this.registerInstaller(new NpmInstaller(this.execPromise));
-        this.registerInstaller(new PipInstaller(this.execPromise));
-        this.registerInstaller(new CommandInstaller(this.execPromise));
-        this.registerInstaller(new GeneralInstaller(this.execPromise));
-    }
-    /**
-     * Register a custom installer
-     * @param installer The installer to register
-     */
-    registerInstaller(installer) {
-        this.installers.push(installer);
-    }
-    /**
-     * Get the appropriate installer for a requirement
-     * @param requirement The requirement to get an installer for
-     * @returns The appropriate installer, or undefined if none found
-     */
-    getInstaller(requirement) {
-        // Validate that if registry is empty, type must not be 'other'
-        if (!requirement.registry && requirement.type === 'other') {
-            throw new Error('Registry must be specified for requirement type "other"');
-        }
-        return this.installers.find(installer => installer.canHandle(requirement));
-    }
-    /**
-     * Install a requirement using the appropriate installer
-     * @param requirement The requirement to install
-     * @param options Installation options including python environment
-     * @returns The installation status
-     */
-    async install(requirement, options) {
-        const installer = this.getInstaller(requirement);
-        if (!installer) {
-            return {
-                name: requirement.name,
-                type: requirement.type,
-                installed: false,
-                error: `No installer found for requirement type '${requirement.type}'`,
-                inProgress: false
-            };
-        }
-        return await installer.install(requirement, options);
-    }
-    /**
-      * Check the installation status of a requirement
-      * @param requirement The requirement to check
-      * @param options Installation options including python environment
-      * @returns The installation status
-      */
-    async checkInstallation(requirement, options) {
-        const installer = this.getInstaller(requirement);
-        if (!installer) {
-            return {
-                name: requirement.name,
-                type: requirement.type,
-                installed: false,
-                error: `No installer found for requirement type '${requirement.type}'`,
-                inProgress: false
-            };
-        }
-        return await installer.checkInstallation(requirement, options);
-    }
-}
-/**
- * Create a new InstallerFactory with default settings
- * @param execPromise Optional function to execute commands
- * @returns A new InstallerFactory
- */
-export const createInstallerFactory = (execPromise = util.promisify(exec)) => {
-    return new InstallerFactory(execPromise);
-};
-//# sourceMappingURL=InstallerFactory.js.map

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

@@ -1,26 +0,0 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
-import { BaseInstaller } from './BaseInstaller.js';
-/**
- * Installer implementation for NPM packages
- */
-export declare class NpmInstaller 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 NPM package is already installed
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
-    /**
-     * Install the NPM package
-     * @param requirement The requirement to install
-     * @returns The status of the installation
-     */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
-}

package/dist/core/installers/NpmInstaller.js

@@ -1,127 +0,0 @@
-import { BaseInstaller } from './BaseInstaller.js';
-import { compareVersions } from '../../utils/versionUtils.js';
-/**
- * Installer implementation for NPM packages
- */
-export class NpmInstaller 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) {
-        return requirement.type === 'npm';
-    }
-    supportCheckUpdates() {
-        return true;
-    }
-    /**
-     * Check if the NPM package is already installed
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    async checkInstallation(requirement) {
-        try {
-            const { stdout } = await this.execPromise(`npm list -g ${requirement.name} --json`);
-            const pkgInfo = JSON.parse(stdout);
-            const installedVersion = pkgInfo?.dependencies?.[requirement.name]?.version;
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: !!installedVersion,
-                version: installedVersion,
-                inProgress: false
-            };
-        }
-        catch (error) {
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
-        }
-    }
-    /**
-     * Install the NPM package
-     * @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 && status.version && compareVersions(status.version, requirement.version) === 0) {
-                return status;
-            }
-            let resolvedVersion = requirement.version;
-            // If no registry is specified, use standard npm installation
-            if (!requirement.registry) {
-                const { stderr } = await this.execPromise(`npm install -g ${requirement.name}@${requirement.version}`);
-                if (stderr && !stderr.includes('added')) {
-                    throw new Error(stderr);
-                }
-            }
-            else {
-                // Handle different registry types
-                let packageSource;
-                if (requirement.registry.githubRelease) {
-                    const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                    packageSource = result.resolvedPath;
-                    resolvedVersion = result.resolvedVersion;
-                }
-                else if (requirement.registry.artifacts) {
-                    // For npm with artifacts, configure npm to use the specified registry URL
-                    const registryUrl = requirement.registry.artifacts.registryUrl;
-                    await this.execPromise(`npm config set registry ${registryUrl}`);
-                    // Now install the package with the configured registry
-                    const { stderr } = await this.execPromise(`npm install -g ${requirement.name}@${requirement.version}`);
-                    if (stderr && !stderr.includes('added')) {
-                        // Reset the registry to the default npm registry
-                        await this.execPromise('npm config set registry https://registry.npmjs.org/');
-                        throw new Error(stderr);
-                    }
-                    // Reset the registry to the default npm registry
-                    await this.execPromise('npm config set registry https://registry.npmjs.org/');
-                    return {
-                        name: requirement.name,
-                        type: 'npm',
-                        installed: true,
-                        version: requirement.version,
-                        inProgress: false
-                    };
-                }
-                else if (requirement.registry.local) {
-                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
-                }
-                else {
-                    throw new Error('Invalid registry configuration');
-                }
-                // Install from the package source
-                const { stderr } = await this.execPromise(`npm install -g "${packageSource}"`);
-                if (stderr && !stderr.includes('added')) {
-                    const status = await this.checkInstallation(requirement);
-                    if (!status.installed)
-                        throw new Error(stderr);
-                }
-            }
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: true,
-                version: resolvedVersion,
-                inProgress: false
-            };
-        }
-        catch (error) {
-            return {
-                name: requirement.name,
-                type: 'npm',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
-        }
-    }
-}
-//# sourceMappingURL=NpmInstaller.js.map

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

@@ -1,28 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../types.js';
-import { BaseInstaller } from './BaseInstaller.js';
-/**
- * Installer implementation for Python packages using pip
- */
-export declare class PipInstaller extends BaseInstaller {
-    private getPythonCommand;
-    private getPipCommand;
-    /**
-     * 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 Python package is already installed
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    /**
-     * Install the Python package
-     * @param requirement The requirement to install
-     * @returns The status of the installation
-     */
-    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-}