imcp 0.1.4 → 0.1.6

package/dist/core/installers/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/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>;
+}

package/dist/core/installers/GeneralInstaller.js

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,127 @@
+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

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