imcp 0.0.14 → 0.0.16

package/dist/core/installers/clients/ClientInstallerFactory.d.ts

@@ -0,0 +1,20 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+/**
+ * Factory for creating client-specific installers
+ * Handles creation of appropriate installer based on client type
+ */
+export declare class ClientInstallerFactory {
+    private static readonly installerMap;
+    /**
+     * Get a client installer instance based on client type
+     * @param clientName Name of the client to get installer for
+     * @returns Client-specific installer instance or undefined if client not supported
+     */
+    static getInstaller(clientName: string): BaseClientInstaller | undefined;
+    /**
+     * Check if a client is supported
+     * @param clientName Name of the client to check
+     * @returns True if client is supported, false otherwise
+     */
+    static isClientSupported(clientName: string): boolean;
+}

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

@@ -0,0 +1,37 @@
+import { MSRooCodeInstaller } from './MSRooCodeInstaller.js';
+import { ClineInstaller } from './ClineInstaller.js';
+import { GithubCopilotInstaller } from './GithubCopilotInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+/**
+ * Factory for creating client-specific installers
+ * Handles creation of appropriate installer based on client type
+ */
+export class ClientInstallerFactory {
+    static installerMap = {
+        [Object.keys(SUPPORTED_CLIENTS)[0]]: MSRooCodeInstaller,
+        [Object.keys(SUPPORTED_CLIENTS)[1]]: ClineInstaller,
+        [Object.keys(SUPPORTED_CLIENTS)[2]]: GithubCopilotInstaller
+    };
+    /**
+     * Get a client installer instance based on client type
+     * @param clientName Name of the client to get installer for
+     * @returns Client-specific installer instance or undefined if client not supported
+     */
+    static getInstaller(clientName) {
+        // Check if client is supported
+        if (!SUPPORTED_CLIENTS[clientName]) {
+            return undefined;
+        }
+        const InstallerClass = this.installerMap[clientName];
+        return InstallerClass ? new InstallerClass() : undefined;
+    }
+    /**
+     * Check if a client is supported
+     * @param clientName Name of the client to check
+     * @returns True if client is supported, false otherwise
+     */
+    static isClientSupported(clientName) {
+        return !!SUPPORTED_CLIENTS[clientName];
+    }
+}
+//# sourceMappingURL=ClientInstallerFactory.js.map

package/dist/core/installers/clients/ClineInstaller.d.ts

@@ -0,0 +1,18 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+/**
+ * Cline client installer implementation
+ * Handles installation of Cline client including extension installation and settings configuration
+ */
+export declare class ClineInstaller extends BaseClientInstaller {
+    /**
+     * Install Cline client
+     * @param options Installation options including environment variables and arguments
+     */
+    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    /**
+     * Set up Cline client settings
+     * Updates VS Code settings with MCP server configuration
+     */
+    setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void>;
+}

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

@@ -0,0 +1,124 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { Logger } from '../../../utils/logger.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+/**
+ * Cline client installer implementation
+ * Handles installation of Cline client including extension installation and settings configuration
+ */
+export class ClineInstaller extends BaseClientInstaller {
+    /**
+     * Install Cline client
+     * @param options Installation options including environment variables and arguments
+     */
+    async install(serverConfig, options) {
+        const operationId = this.generateOperationId();
+        try {
+            // Check if VS Code or VS Code Insiders is installed
+            const isVSCodeInstalled = await isCommandAvailable('code');
+            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
+                    operationId
+                };
+            }
+            // Install extension
+            const extensionResult = await ExtensionInstaller.installExtension('Cline');
+            if (!extensionResult) {
+                Logger.debug('Failed to install Cline extension');
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Failed to install Cline extension',
+                    operationId
+                };
+            }
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+            // Track success for both VS Code variants
+            const results = [];
+            // Update settings for VS Code if installed
+            if (isVSCodeInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['Cline'].codeSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                }
+                catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['Cline'].codeSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            // Update settings for VS Code Insiders if installed
+            if (isVSCodeInsidersInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['Cline'].codeInsiderSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                }
+                catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['Cline'].codeInsiderSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess
+                    ? `Successfully installed Cline client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install Cline client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing Cline client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Set up Cline client settings
+     * Updates VS Code settings with MCP server configuration
+     */
+    async setupClientSettings(settingPath, serverName, installConfig) {
+        // Read existing settings
+        const settings = await readJsonFile(settingPath, true);
+        // Initialize settings with client-specific structure
+        this.initializeSettings(settings);
+        // Handle different modes
+        if (installConfig.mode === 'stdio') {
+            // Process config for Windows NPX if needed
+            const finalConfig = await this.handleWindowsNpx(installConfig);
+            await this.handleStdioMode(settings, serverName, finalConfig);
+        }
+        else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}
+//# sourceMappingURL=ClineInstaller.js.map

package/dist/core/installers/clients/GithubCopilotInstaller.d.ts

@@ -0,0 +1,34 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+/**
+ * Github Copilot client installer implementation
+ * Handles installation of Github Copilot client including extension installation and settings configuration
+ */
+export declare class GithubCopilotInstaller extends BaseClientInstaller {
+    /**
+     * Install Github Copilot client
+     * @param options Installation options including environment variables and arguments
+     */
+    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    /**
+     * Initialize settings with GithubCopilot-specific structure
+     * Overrides base method to provide custom initialization
+     */
+    protected initializeSettings(settings: any): void;
+    /**
+     * Handle stdio mode configuration for GithubCopilot
+     * Overrides base method to provide custom stdio configuration
+     */
+    protected handleStdioMode(settings: any, serverName: string, finalConfig: any): Promise<void>;
+    /**
+     * Handle SSE mode configuration for GithubCopilot
+     * Overrides base method to provide custom SSE configuration
+     */
+    protected handleSseMode(settings: any, serverName: string, installConfig: any): void;
+    /**
+     * Set up Github Copilot client settings
+     * Updates VS Code settings with MCP server configuration
+     * Note: GithubCopilot uses a different settings structure compared to other clients
+     */
+    setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void>;
+}

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

@@ -0,0 +1,162 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { Logger } from '../../../utils/logger.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+/**
+ * Github Copilot client installer implementation
+ * Handles installation of Github Copilot client including extension installation and settings configuration
+ */
+export class GithubCopilotInstaller extends BaseClientInstaller {
+    /**
+     * Install Github Copilot client
+     * @param options Installation options including environment variables and arguments
+     */
+    async install(serverConfig, options) {
+        const operationId = this.generateOperationId();
+        try {
+            // Check if VS Code or VS Code Insiders is installed
+            const isVSCodeInstalled = await isCommandAvailable('code');
+            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
+                    operationId
+                };
+            }
+            // Install extension
+            const extensionResult = await ExtensionInstaller.installExtension('GithubCopilot');
+            if (!extensionResult) {
+                Logger.debug('Failed to install Github Copilot extension');
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Failed to install Github Copilot extension',
+                    operationId
+                };
+            }
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+            // Track success for both VS Code variants
+            const results = [];
+            // Update settings for VS Code if installed
+            if (isVSCodeInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['GithubCopilot'].codeSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                }
+                catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['GithubCopilot'].codeSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            // Update settings for VS Code Insiders if installed
+            if (isVSCodeInsidersInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['GithubCopilot'].codeInsiderSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                }
+                catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['GithubCopilot'].codeInsiderSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess
+                    ? `Successfully installed Github Copilot client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install Github Copilot client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing Github Copilot client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Initialize settings with GithubCopilot-specific structure
+     * Overrides base method to provide custom initialization
+     */
+    initializeSettings(settings) {
+        if (!settings.mcp) {
+            settings.mcp = {
+                servers: {},
+                inputs: []
+            };
+        }
+        if (!settings.mcp.servers) {
+            settings.mcp.servers = {};
+        }
+    }
+    /**
+     * Handle stdio mode configuration for GithubCopilot
+     * Overrides base method to provide custom stdio configuration
+     */
+    async handleStdioMode(settings, serverName, finalConfig) {
+        if (finalConfig.args) {
+            finalConfig.args = finalConfig.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
+        }
+        settings.mcp.servers[serverName] = {
+            command: finalConfig.command,
+            args: finalConfig.args,
+            env: finalConfig.env
+        };
+    }
+    /**
+     * Handle SSE mode configuration for GithubCopilot
+     * Overrides base method to provide custom SSE configuration
+     */
+    handleSseMode(settings, serverName, installConfig) {
+        settings.mcp.servers[serverName] = {
+            type: 'sse',
+            url: installConfig.url
+        };
+    }
+    /**
+     * Set up Github Copilot client settings
+     * Updates VS Code settings with MCP server configuration
+     * Note: GithubCopilot uses a different settings structure compared to other clients
+     */
+    async setupClientSettings(settingPath, serverName, installConfig) {
+        // Read existing settings
+        const settings = await readJsonFile(settingPath, true);
+        // Initialize settings with client-specific structure
+        this.initializeSettings(settings);
+        // Handle different modes
+        if (installConfig.mode === 'stdio') {
+            await this.handleStdioMode(settings, serverName, installConfig);
+        }
+        else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}
+//# sourceMappingURL=GithubCopilotInstaller.js.map

package/dist/core/installers/clients/MSRooCodeInstaller.d.ts

@@ -0,0 +1,15 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { ServerInstallOptions, OperationStatus, McpConfig } from '../../types.js';
+/**
+ * MSRooCode client installer implementation
+ */
+export declare class MSRooCodeInstaller extends BaseClientInstaller {
+    /**
+     * Install MSRooCode client
+     */
+    install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    /**
+     * Set up MSRooCode client settings
+     */
+    setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void>;
+}

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

@@ -0,0 +1,122 @@
+import { BaseClientInstaller } from './BaseClientInstaller.js';
+import { Logger } from '../../../utils/logger.js';
+import { readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+/**
+ * MSRooCode client installer implementation
+ */
+export class MSRooCodeInstaller extends BaseClientInstaller {
+    /**
+     * Install MSRooCode client
+     */
+    async install(serverConfig, options) {
+        const operationId = this.generateOperationId();
+        try {
+            // Check if VS Code or VS Code Insiders is installed
+            const isVSCodeInstalled = await isCommandAvailable('code');
+            const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+            if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Neither VS Code nor VS Code Insiders are installed on this system',
+                    operationId
+                };
+            }
+            // Install extension
+            const extensionResult = await ExtensionInstaller.installExtension('MSRooCode');
+            if (!extensionResult) {
+                Logger.debug('Failed to install MSRooCode extension');
+                return {
+                    status: 'failed',
+                    type: 'install',
+                    target: 'server',
+                    message: 'Failed to install MSRooCode extension',
+                    operationId
+                };
+            }
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+            installConfig.mode = serverConfig.mode;
+            // Track success for both VS Code variants
+            const results = [];
+            // Update settings for VS Code if installed
+            if (isVSCodeInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['MSRooCode'].codeSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                }
+                catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['MSRooCode'].codeSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            // Update settings for VS Code Insiders if installed
+            if (isVSCodeInsidersInstalled) {
+                try {
+                    const settingPath = SUPPORTED_CLIENTS['MSRooCode'].codeInsiderSettingPath;
+                    await this.setupClientSettings(settingPath, serverConfig.name, installConfig);
+                    results.push({ success: true, path: settingPath });
+                }
+                catch (error) {
+                    results.push({
+                        success: false,
+                        path: SUPPORTED_CLIENTS['MSRooCode'].codeInsiderSettingPath,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess
+                    ? `Successfully installed MSRooCode client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install MSRooCode client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing MSRooCode client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Set up MSRooCode client settings
+     */
+    async setupClientSettings(settingPath, serverName, installConfig) {
+        // Read existing settings
+        const settings = await readJsonFile(settingPath, true);
+        // Initialize settings with client-specific structure
+        this.initializeSettings(settings);
+        // Handle different modes
+        if (installConfig.mode === 'stdio') {
+            // Process config for Windows NPX if needed
+            const finalConfig = await this.handleWindowsNpx(installConfig);
+            await this.handleStdioMode(settings, serverName, finalConfig);
+        }
+        else if (installConfig.mode === 'sse') {
+            this.handleSseMode(settings, serverName, installConfig);
+        }
+        // Write updated settings
+        await writeJsonFile(settingPath, settings);
+    }
+}
+//# sourceMappingURL=MSRooCodeInstaller.js.map

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

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus, RegistryConfig, ServerInstallOptions } from '../../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 /**
  * Abstract base class with common functionality for all requirement installers
@@ -17,43 +17,20 @@ export declare abstract class BaseInstaller implements RequirementInstaller {
     abstract supportCheckUpdates(): boolean;
     abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
     abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Get the latest version available for the requirement.
+     * This method needs to be implemented by concrete installers.
+     * @param requirement The requirement to check.
+     * @param options Optional server install options.
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    abstract getLatestVersion(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<string | undefined>;
     /**
      * Check if updates are available for the requirement
      * @param requirement The requirement to check
      * @param currentStatus The current status of the requirement
+     * @param options Optional server install options.
      * @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>;
+    checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus, options?: ServerInstallOptions): Promise<RequirementStatus>;
 }