imcp 0.0.4 → 0.0.6

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

@@ -0,0 +1,86 @@
+import { BaseInstaller } from './BaseInstaller.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.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 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/requirements/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/requirements/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/requirements/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/requirements/NpmInstaller.js

@@ -0,0 +1,128 @@
+import { BaseInstaller } from './BaseInstaller.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.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 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/requirements/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>;
+}

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

@@ -0,0 +1,128 @@
+import { BaseInstaller } from './BaseInstaller.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+/**
+ * Installer implementation for Python packages using pip
+ */
+export class PipInstaller extends BaseInstaller {
+    getPythonCommand(options) {
+        return options?.settings?.pythonEnv || 'python';
+    }
+    getPipCommand(options) {
+        const pythonCmd = this.getPythonCommand(options);
+        return `${pythonCmd} -m pip`;
+    }
+    /**
+     * 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 === 'pip';
+    }
+    supportCheckUpdates() {
+        /// temporarily disabling update check for pip as not able to get which pip of python is being used
+        return false;
+    }
+    /**
+     * Check if the Python package is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement, options) {
+        try {
+            const pipCmd = this.getPipCommand(options);
+            const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
+            // If we get an output and no error, the package is installed
+            const installed = stdout.includes(requirement.name);
+            const versionMatch = stdout.match(/Version: (.+)/);
+            const installedVersion = versionMatch ? versionMatch[1] : undefined;
+            return {
+                name: requirement.name,
+                type: 'pip',
+                installed,
+                version: installedVersion,
+                inProgress: false
+            };
+        }
+        catch (error) {
+            return {
+                name: requirement.name,
+                type: 'pip',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+    /**
+     * Install the Python package
+     * @param requirement The requirement to install
+     * @returns The status of the installation
+     */
+    async install(requirement, options) {
+        try {
+            const status = await this.checkInstallation(requirement, options);
+            if (status.installed) {
+                return status;
+            }
+            const pipCmd = this.getPipCommand(options);
+            // If no registry is specified, use standard pip installation
+            if (!requirement.registry) {
+                // Standard pip installation
+                const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
+                if (stderr && stderr.toLowerCase().includes('error')) {
+                    throw new Error(stderr);
+                }
+            }
+            else {
+                // Handle different registry types
+                let packageSource;
+                if (requirement.registry.githubRelease) {
+                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                    packageSource = result.resolvedPath;
+                    // Install from the downloaded wheel or tar.gz file
+                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
+                    if (stderr && stderr.toLowerCase().includes('error')) {
+                        throw new Error(stderr);
+                    }
+                }
+                else if (requirement.registry.artifacts) {
+                    const registryUrl = requirement.registry.artifacts.registryUrl;
+                    // Install using the custom index URL
+                    const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`);
+                    if (stderr && stderr.toLowerCase().includes('error')) {
+                        throw new Error(stderr);
+                    }
+                }
+                else if (requirement.registry.local) {
+                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
+                    // Install from the local path
+                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
+                    if (stderr && stderr.toLowerCase().includes('error')) {
+                        throw new Error(stderr);
+                    }
+                }
+                else {
+                    throw new Error('Invalid registry configuration');
+                }
+            }
+            return {
+                name: requirement.name,
+                type: 'pip',
+                installed: true,
+                version: requirement.version,
+                inProgress: false
+            };
+        }
+        catch (error) {
+            return {
+                name: requirement.name,
+                type: 'pip',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+}
+//# sourceMappingURL=PipInstaller.js.map

package/{src/core/installers/RequirementInstaller.ts → dist/core/installers/requirements/RequirementInstaller.d.ts}

@@ -1,38 +1,33 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
-
-/**
- * Interface for requirement installers.
- * Implementations should handle specific requirement types.
- */
-export interface RequirementInstaller {
-    /**
-     * 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;
-
-    /**
-     * Install the requirement
-     * @param requirement The requirement to install
-     * @returns The status of the installation
-     */
-    install(requirement: RequirementConfig): Promise<RequirementStatus>;
-
-    /**
-     * Check if the requirement is already installed
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    checkInstallation(requirement: RequirementConfig): 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>;
-}
-
-// Note: Do not re-export implementations from here to avoid circular dependencies
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+/**
+ * Interface for requirement installers.
+ * Implementations should handle specific requirement types.
+ */
+export interface RequirementInstaller {
+    /**
+     * 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;
+    /**
+     * Install the requirement
+     * @param requirement The requirement to install
+     * @returns The status of the installation
+     */
+    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Check if the requirement is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    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>;
+}

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

@@ -0,0 +1,3 @@
+export {};
+// Note: Do not re-export implementations from here to avoid circular dependencies
+//# sourceMappingURL=RequirementInstaller.js.map

package/dist/core/types.d.ts

@@ -64,6 +64,8 @@ export interface ServerInstallOptions {
     env?: Record<string, string>;
     targetClients?: string[];
     requirements?: RequirementConfig[];
+    args?: string[];
+    settings?: Record<string, any>;
 }
 export interface UpdateRequirementOptions {
     requirementName: string;
@@ -86,6 +88,7 @@ export interface DependencyConfig {
     requirements?: Array<{
         name: string;
         version: string;
+        order?: number;
     }>;
     mcpServers?: Array<{
         name: string;
@@ -115,7 +118,7 @@ export interface RegistryConfig {
 }
 export interface RequirementConfig {
     name: string;
-    type: 'npm' | 'pip' | 'command' | 'other';
+    type: 'npm' | 'pip' | 'command' | 'extension' | 'other';
     alias?: string;
     version: string;
     registry?: RegistryConfig;

package/dist/services/ServerService.js

@@ -71,7 +71,7 @@ export class ServerService {
                         }
                     }
                     // Check for updates
-                    const updatedStatus = await requirementService.checkRequirementForUpdates(requirement);
+                    const updatedStatus = await requirementService.checkRequirementForUpdates(requirement, currentStatus);
                     // If update information is found, update the configuration
                     if (updatedStatus.availableUpdate && serverCategory.name) {
                         await configProvider.updateRequirementStatus(serverCategory.name, requirement.name, updatedStatus);