imcp 0.0.3 → 0.0.5

package/src/core/installers/{ClientInstaller.ts → clients/ClientInstaller.ts}

@@ -1,3 +1,4 @@
+import { ExtensionInstaller } from './ExtensionInstaller.js';
 import {
     ServerOperationResult,
     OperationStatus,
@@ -6,13 +7,18 @@ import {
     ServerInstallOptions,
     FeedConfiguration,
     McpConfig
-} from '../types.js';
-import { ConfigurationProvider } from '../ConfigurationProvider.js';
-import { SUPPORTED_CLIENTS } from '../constants.js';
-import { resolveNpmModulePath, readJsonFile, writeJsonFile } from '../../utils/clientUtils.js';
+} from '../../types.js';
+import { GetBrowserPath } from '../../../utils/osUtils.js';
+import { ConfigurationProvider } from '../../ConfigurationProvider.js';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { resolveNpmModulePath, readJsonFile, writeJsonFile } from '../../../utils/clientUtils.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { Logger } from '../../utils/logger.js';
+import * as path from 'path';
+import { Logger } from '../../../utils/logger.js';
+import { getPythonPackagePath, getSystemPythonPackageDirectory } from '../../../utils/osUtils.js';
+
+const execAsync = promisify(exec); // Moved promisify here for reuse
 
 export class ClientInstaller {
     private configProvider: ConfigurationProvider;
@@ -32,7 +38,6 @@ export class ClientInstaller {
     }
 
     private async getNpmPath(): Promise<string> {
-        const execAsync = promisify(exec);
         try {
             // Execute the get-command npm command to find the npm path
             const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
@@ -47,28 +52,48 @@ export class ClientInstaller {
         }
     }
 
+
     /**
      * Check if a command is available on the system
      * @param command The command to check
      * @returns True if the command is available, false otherwise
      */
     private async isCommandAvailable(command: string): Promise<boolean> {
-        const execAsync = promisify(exec);
         try {
             if (process.platform === 'win32') {
                 // Windows-specific command check
                 await execAsync(`where ${command}`);
+            } else if (process.platform === 'darwin' && (command === 'code' || command === 'code-insiders')) {
+                // macOS-specific VS Code check
+                const vscodePath = command === 'code' ?
+                    '/Applications/Visual Studio Code.app' :
+                    '/Applications/Visual Studio Code - Insiders.app';
+                await execAsync(`test -d "${vscodePath}"`);
             } else {
                 // Unix-like systems
                 await execAsync(`which ${command}`);
             }
             return true;
         } catch (error) {
+            if (process.platform === 'darwin' && (command === 'code' || command === 'code-insiders')) {
+                // Try checking in ~/Applications as well for macOS
+                try {
+                    const homedir = process.env.HOME;
+                    const vscodePath = command === 'code' ?
+                        `${homedir}/Applications/Visual Studio Code.app` :
+                        `${homedir}/Applications/Visual Studio Code - Insiders.app`;
+                    await execAsync(`test -d "${vscodePath}"`);
+                    return true;
+                } catch (error) {
+                    return false;
+                }
+            }
             return false;
         }
     }
 
-    private async installClient(clientName: string, env?: Record<string, string>): Promise<OperationStatus> {
+    // Modified to accept ServerInstallOptions
+    private async installClient(clientName: string, options: ServerInstallOptions): Promise<OperationStatus> {
         // Check if client is supported
         if (!SUPPORTED_CLIENTS[clientName]) {
             return {
@@ -99,14 +124,18 @@ export class ClientInstaller {
         );
 
         // Start the asynchronous installation process without awaiting it
-        this.processInstallation(clientName, operationId, env);
+        // Pass options down
+        this.processInstallation(clientName, operationId, options);
 
         // Return the initial status immediately
         return initialStatus;
     }
 
-    private async processInstallation(clientName: string, operationId: string, env?: Record<string, string>): Promise<void> {
+    // Modified to accept ServerInstallOptions
+    private async processInstallation(clientName: string, operationId: string, options: ServerInstallOptions): Promise<void> {
         try {
+            await ExtensionInstaller.installExtension(clientName);
+
             // Check requirements before installation
             let requirementsReady = await this.configProvider.isRequirementsReady(this.categoryName, this.serverName);
 
@@ -217,8 +246,16 @@ export class ClientInstaller {
             }
 
             try {
-                // Install client-specific configuration
-                const result = await this.installClientConfig(clientName, env || {}, serverConfig, feedConfiguration);
+                // Install extension if available
+                if (SUPPORTED_CLIENTS[clientName]?.extension) {
+                    const extensionResult = await ExtensionInstaller.installExtension(clientName);
+                    if (!extensionResult) {
+                        Logger.debug(`Failed to install extension for client ${clientName}`);
+                    }
+                }
+
+                // Install client-specific configuration, passing options down
+                const result = await this.installClientConfig(clientName, options, serverConfig, feedConfiguration);
 
                 const finalStatus: OperationStatus = {
                     status: result.success ? 'completed' : 'failed',
@@ -236,6 +273,10 @@ export class ClientInstaller {
                     finalStatus
                 );
 
+                if (result.success) {
+                    await this.configProvider.reloadClientMCPSettings();
+                }
+
             } catch (error) {
                 const errorStatus: OperationStatus = {
                     status: 'failed',
@@ -272,9 +313,10 @@ export class ClientInstaller {
         }
     }
 
+    // Modified to accept ServerInstallOptions
     private async installClientConfig(
         clientName: string,
-        env: Record<string, string>,
+        options: ServerInstallOptions, // Use options directly
         serverConfig: McpConfig,
         feedConfig: FeedConfiguration
     ): Promise<{ success: boolean; message: string }> {
@@ -299,7 +341,6 @@ export class ClientInstaller {
             const isVSCodeInsidersInstalled = await this.isCommandAvailable('code-insiders');
             Logger.debug(isVSCodeInstalled ? 'VS Code detected on system' : 'VS Code not detected on system');
             Logger.debug(isVSCodeInsidersInstalled ? 'VS Code Insiders detected on system' : 'VS Code Insiders not detected on system');
-            Logger.debug(`VS Code Insiders installed: ${isVSCodeInsidersInstalled}`);
 
             // If neither is installed, we can't proceed
             if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
@@ -310,29 +351,102 @@ export class ClientInstaller {
                 };
             }
 
-            // Clone the installation configuration to make modifications
+            // --- Start of new logic ---
+
+            // Clone the base installation configuration to avoid modifying the original serverConfig
             const installConfig = JSON.parse(JSON.stringify(serverConfig.installation));
+            const pythonEnv = options.settings?.pythonEnv;
+            let pythonDir: string | null = null;
+
+            // 1. Determine which args to use and resolve npm paths
+            let finalArgs: string[] = [];
+            if (options.args && options.args.length > 0) {
+                Logger.debug(`Using args from ServerInstallOptions: ${options.args.join(' ')}`);
+                finalArgs = options.args.map(arg => resolveNpmModulePath(arg));
+            } else if (installConfig.args && installConfig.args.length > 0) {
+                Logger.debug(`Using args from serverConfig.installation: ${installConfig.args.join(' ')}`);
+                finalArgs = installConfig.args.map((arg: string) => resolveNpmModulePath(arg));
+            } else {
+                Logger.debug('No args found in options or serverConfig.installation.');
+                finalArgs = [];
+            }
+
+            // 2. Handle pythonEnv settings
+            if (pythonEnv) {
+                // 2.1 If pythonEnv is set
+                Logger.debug(`Python environment specified: ${pythonEnv}`);
+                pythonDir = getPythonPackagePath(pythonEnv);
 
-            // Replace template variables in args
-            installConfig.args = installConfig.args.map((arg: string) =>
-                resolveNpmModulePath(arg));
-
-            // Add environment variables from options
-            installConfig.env = {};
-            if (serverConfig.installation.env) {
-                // Add default env variables from config
-                for (const [key, config] of Object.entries(serverConfig.installation.env)) {
-                    const envConfig = config as any; // Type assertion for dynamic access
-                    if (envConfig.Default) {
-                        installConfig.env[key] = envConfig.Default;
+                // 2.1.1 Replace ${PYTHON_PACKAGE} in args
+                if (pythonDir) {
+                    finalArgs = finalArgs.map(arg => arg.includes('${PYTHON_PACKAGE}') ? arg.replace('${PYTHON_PACKAGE}', pythonDir!) : arg);
+                    Logger.debug(`Args after PYTHON_PACKAGE replacement (using pythonEnv): ${finalArgs.join(' ')}`);
+                } else {
+                    Logger.debug(`Could not determine directory for pythonEnv: ${pythonEnv}`);
+                }
+
+                // 2.1.2 Replace command if it's 'python'
+                if (installConfig.command === 'python') {
+                    Logger.debug(`Replacing command 'python' with specified pythonEnv: ${pythonEnv}`);
+                    installConfig.command = pythonEnv;
+                }
+            } else {
+                // 2.2 If pythonEnv is not set
+                Logger.debug('No Python environment specified in settings.');
+                // 2.2.1 Replace ${PYTHON_PACKAGE} with system python directory if needed
+                if (finalArgs.some(arg => arg.includes('${PYTHON_PACKAGE}'))) {
+                    Logger.debug('Attempting to find system Python directory for ${PYTHON_PACKAGE} replacement.');
+                    pythonDir = await getSystemPythonPackageDirectory();
+                    if (pythonDir) {
+                        finalArgs = finalArgs.map(arg => arg.includes('${PYTHON_PACKAGE}') ? arg.replace('${PYTHON_PACKAGE}', pythonDir!) : arg);
+                        Logger.debug(`Args after PYTHON_PACKAGE replacement (using system python): ${finalArgs.join(' ')}`);
+                    } else {
+                        Logger.debug('Could not find system Python directory. ${PYTHON_PACKAGE} replacement skipped.');
+                        // Optionally, remove or handle the arg containing ${PYTHON_PACKAGE} if Python is required
+                        // finalArgs = finalArgs.filter(arg => !arg.includes('${PYTHON_PACKAGE}'));
                     }
                 }
             }
 
-            // Override with provided env variables
-            if (env) {
-                Object.assign(installConfig.env, env);
+            // Update installConfig with potentially modified args
+            installConfig.args = finalArgs;
+
+
+            // 3. Handle environment variables (merge default, serverConfig, and options.env)
+            const baseEnv = serverConfig.installation.env || {};
+            const defaultEnv: Record<string, string> = {};
+            for (const [key, config] of Object.entries(baseEnv)) {
+                const envConfig = config as any; // Type assertion
+                if (envConfig.Default) {
+                    defaultEnv[key] = envConfig.Default;
+                }
             }
+            // Merge: options.env overrides defaultEnv
+            installConfig.env = { ...defaultEnv, ...(options.env || {}) };
+
+            // Replace ${BROWSER_PATH} with actual browser path
+            const replacements = Object.entries(installConfig.env)
+                .filter(([_, value]) => typeof value === 'string' && value.includes('${BROWSER_PATH}'))
+                .map(async ([key, value]) => {
+                    try {
+                        const browserPath = await GetBrowserPath();
+                        return [key, (value as string).replace('${BROWSER_PATH}', browserPath)] as [string, string];
+                    } catch (error) {
+                        Logger.error(`Failed to get system browser path for env var ${key}:`, error);
+                        return [key, value] as [string, string];
+                    }
+                });
+
+            // Wait for all replacements to complete
+            const replacedValues = await Promise.all(replacements);
+            replacedValues.forEach(([key, value]) => {
+                installConfig.env[key] = value;
+            });
+
+            Logger.debug(`Final environment variables: ${JSON.stringify(installConfig.env)}`);
+
+            // --- End of new logic ---
+
 
             // Keep track of success for both installations
             let regularSuccess = false;
@@ -345,6 +459,7 @@ export class ClientInstaller {
                 if (isVSCodeInstalled) {
                     try {
                         Logger.debug(`Updating VS Code settings for ${clientName} at path: ${regularSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateClineOrMSRooSettings(regularSettingPath, this.serverName, installConfig, clientName);
                         regularSuccess = true;
                         Logger.debug(`Settings successfully updated to ${regularSettingPath} for ${clientName} (VS Code)`);
@@ -359,6 +474,7 @@ export class ClientInstaller {
                 if (isVSCodeInsidersInstalled) {
                     try {
                         Logger.debug(`Updating VS Code Insiders settings for ${clientName} at path: ${insidersSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateClineOrMSRooSettings(insidersSettingPath, this.serverName, installConfig, clientName);
                         insidersSuccess = true;
                         Logger.debug(`Settings successfully updated to ${insidersSettingPath} for ${clientName} (VS Code Insiders)`);
@@ -373,6 +489,7 @@ export class ClientInstaller {
                 if (isVSCodeInstalled) {
                     try {
                         Logger.debug(`Updating VS Code settings for ${clientName} at path: ${regularSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateGithubCopilotSettings(regularSettingPath, this.serverName, installConfig);
                         regularSuccess = true;
                         Logger.debug(`Settings successfully updated to ${regularSettingPath} for ${clientName} (VS Code)`);
@@ -387,6 +504,7 @@ export class ClientInstaller {
                 if (isVSCodeInsidersInstalled) {
                     try {
                         Logger.debug(`Updating VS Code Insiders settings for ${clientName} at path: ${insidersSettingPath}`);
+                        // Pass the modified installConfig
                         await this.updateGithubCopilotSettings(insidersSettingPath, this.serverName, installConfig);
                         insidersSuccess = true;
                         Logger.debug(`Settings successfully updated to ${insidersSettingPath} for ${clientName} (VS Code Insiders)`);
@@ -459,7 +577,7 @@ export class ClientInstaller {
     private async updateClineOrMSRooSettings(
         settingPath: string,
         serverName: string,
-        installConfig: any,
+        installConfig: any, // Use the processed installConfig
         clientName: string
     ): Promise<void> {
         // Read the Cline/MSRoo settings file
@@ -471,35 +589,44 @@ export class ClientInstaller {
         }
 
         // Special handling for Windows when command is npx for Cline and MSROO clients
-        const serverConfig = { ...installConfig };
+        // Use a copy to avoid modifying the passed installConfig directly if needed elsewhere
+        const serverConfigForClient = { ...installConfig };
         if (process.platform === 'win32' &&
-            serverConfig.command === 'npx' &&
+            serverConfigForClient.command === 'npx' &&
             (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
             // Update command to cmd
-            serverConfig.command = 'cmd';
+            serverConfigForClient.command = 'cmd';
 
             // Add /c and npx at the beginning of args
-            serverConfig.args = ['/c', 'npx', ...serverConfig.args];
+            serverConfigForClient.args = ['/c', 'npx', ...serverConfigForClient.args];
 
             // Add APPDATA environment variable pointing to npm directory
-            if (!serverConfig.env) {
-                serverConfig.env = {};
+            if (!serverConfigForClient.env) {
+                serverConfigForClient.env = {};
             }
 
             // Dynamically get npm path and set APPDATA to it
             const npmPath = await this.getNpmPath();
-            serverConfig.env['APPDATA'] = npmPath;
+            serverConfigForClient.env['APPDATA'] = npmPath;
+            Logger.debug(`Windows npx fix: command=${serverConfigForClient.command}, args=${serverConfigForClient.args.join(' ')}, env=${JSON.stringify(serverConfigForClient.env)}`);
+        }
+        // Convert backslashes to forward slashes in args paths
+        if (serverConfigForClient.args) {
+            serverConfigForClient.args = serverConfigForClient.args.map((arg: string) =>
+                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+            );
         }
 
         // Add or update the server configuration
         settings.mcpServers[serverName] = {
-            command: serverConfig.command,
-            args: serverConfig.args,
-            env: serverConfig.env,
+            command: serverConfigForClient.command,
+            args: serverConfigForClient.args,
+            env: serverConfigForClient.env,
             autoApprove: [],
             disabled: false,
             alwaysAllow: []
         };
+        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcpServers[serverName])}`);
 
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);
@@ -508,7 +635,7 @@ export class ClientInstaller {
     private async updateGithubCopilotSettings(
         settingPath: string,
         serverName: string,
-        installConfig: any
+        installConfig: any // Use the processed installConfig
     ): Promise<void> {
         // Read the VS Code settings.json file
         const settings = await readJsonFile(settingPath, true);
@@ -525,12 +652,23 @@ export class ClientInstaller {
             settings.mcp.servers = {};
         }
 
+        // Use a copy to avoid modifying the passed installConfig directly
+        const serverConfigForClient = { ...installConfig };
+
+        // Convert backslashes to forward slashes in args paths
+        if (serverConfigForClient.args) {
+            serverConfigForClient.args = serverConfigForClient.args.map((arg: string) =>
+                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+            );
+        }
+
         // Add or update the server configuration
         settings.mcp.servers[serverName] = {
-            command: installConfig.command,
-            args: installConfig.args,
-            env: installConfig.env
+            command: serverConfigForClient.command,
+            args: serverConfigForClient.args,
+            env: serverConfigForClient.env
         };
+        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcp.servers[serverName])}`);
 
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);
@@ -540,8 +678,9 @@ export class ClientInstaller {
         const initialStatuses: OperationStatus[] = [];
 
         // Start installation for each client asynchronously and collect initial statuses
+        // Pass options down to installClient
         const installPromises = this.clients.map(async (clientName) => {
-            const initialStatus = await this.installClient(clientName, options.env || {});
+            const initialStatus = await this.installClient(clientName, options);
             initialStatuses.push(initialStatus);
             return initialStatus;
         });

package/src/core/installers/clients/ExtensionInstaller.ts

@@ -0,0 +1,162 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { SUPPORTED_CLIENTS } from '../../constants.js';
+import { Logger } from '../../../utils/logger.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+
+const execAsync = promisify(exec);
+
+interface ExtensionInfo {
+    name: string;
+    publisher: string;
+    version: string;
+}
+
+export class ExtensionInstaller {
+    /**
+     * Get VSCode path based on the OS type
+     */
+    private static async getVSCodePath(isInsiders: boolean): Promise<string | null> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            if (process.platform === 'win32') {
+                // Windows: Check command availability first
+                await execAsync(`where ${command}`);
+                return command;
+            } else if (process.platform === 'darwin') {
+                // macOS: Check in both system and user Applications
+                const appName = isInsiders ? 'Visual Studio Code - Insiders.app' : 'Visual Studio Code.app';
+                const systemPath = `/Applications/${appName}`;
+                const userPath = `${process.env.HOME}/Applications/${appName}`;
+
+                try {
+                    await execAsync(`test -d "${systemPath}"`);
+                    return systemPath;
+                } catch {
+                    try {
+                        await execAsync(`test -d "${userPath}"`);
+                        return userPath;
+                    } catch {
+                        return null;
+                    }
+                }
+            }
+            return command;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * List installed extensions for VSCode or VSCode Insiders
+     */
+    private static async listExtensions(isInsiders: boolean): Promise<ExtensionInfo[]> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            const { stdout } = await execAsync(`${command} --list-extensions --show-versions`);
+            return stdout.split('\n')
+                .filter(line => line.trim())
+                .map(line => {
+                    const [extension, version] = line.split('@');
+                    const [publisher, name] = extension.split('.');
+                    return { name, publisher, version: version || '' };
+                });
+        } catch (error) {
+            Logger.error(`Failed to list extensions for ${command}:`, error);
+            return [];
+        }
+    }
+
+    /**
+     * Check if an extension is installed and get its version
+     */
+    private static async checkExtension(extensionId: string, isInsiders: boolean): Promise<string | null> {
+        const extensions = await this.listExtensions(isInsiders);
+        const [publisher, name] = extensionId.split('.');
+        const extension = extensions.find(ext =>
+            ext.publisher.toLowerCase() === publisher.toLowerCase() &&
+            ext.name.toLowerCase() === name.toLowerCase()
+        );
+        return extension ? extension.version : null;
+    }
+
+    /**
+     * Install extension from marketplace
+     */
+    private static async installPublicExtension(extensionId: string, isInsiders: boolean): Promise<boolean> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            await execAsync(`${command} --install-extension ${extensionId}`);
+            return true;
+        } catch (error) {
+            Logger.error(`Failed to install extension ${extensionId}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Install extension from VSIX file
+     */
+    private static async installPrivateExtension(vsixPath: string, isInsiders: boolean): Promise<boolean> {
+        const command = isInsiders ? 'code-insiders' : 'code';
+        try {
+            await execAsync(`${command} --install-extension "${vsixPath}"`);
+            return true;
+        } catch (error) {
+            Logger.error(`Failed to install extension from VSIX ${vsixPath}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Install extension for a specific client
+     */
+    public static async installExtension(clientName: string): Promise<boolean> {
+        const client = SUPPORTED_CLIENTS[clientName];
+        if (!client?.extension?.extensionId) {
+            Logger.error(`No extension configuration found for client ${clientName}`);
+            return false;
+        }
+
+        const { extensionId, leastVersion, repository, assetName, private: isPrivate } = client.extension;
+        let success = false;
+
+        // Check both VSCode and VSCode Insiders
+        for (const isInsiders of [false, true]) {
+            const vscodePath = await this.getVSCodePath(isInsiders);
+            if (!vscodePath) {
+                Logger.debug(`${isInsiders ? 'VSCode Insiders' : 'VSCode'} not found, skipping...`);
+                continue;
+            }
+
+            const currentVersion = await this.checkExtension(extensionId, isInsiders);
+
+            if (!currentVersion || (isPrivate && leastVersion && compareVersions(currentVersion, leastVersion) < 0)) {
+                // Extension not installed or needs update (for private extensions)
+                if (!isPrivate) {
+                    // Install public extension from marketplace
+                    success = await this.installPublicExtension(extensionId, isInsiders);
+                } else {
+                    // Install private extension from GitHub release using latest version
+                    try {
+                        const { resolvedPath } = await handleGitHubRelease(
+                            { name: extensionId, version: 'latest', type: 'extension' },
+                            { repository, assetName }
+                        );
+                        success = await this.installPrivateExtension(resolvedPath, isInsiders);
+                    } catch (error) {
+                        Logger.error(`Failed to install/update private extension ${extensionId}:`, error);
+                        continue;
+                    }
+                }
+            } else {
+                // Extension already installed and up to date
+                Logger.debug(`Extension ${extensionId} is already installed and up to date`);
+                success = true;
+            }
+        }
+
+        return success;
+    }
+}

package/src/core/installers/index.ts

@@ -1,9 +1,11 @@
 // Export the interface
-export { RequirementInstaller } from './RequirementInstaller.js';
+export { RequirementInstaller } from './requirements/RequirementInstaller.js';
+export { ClientInstaller } from './clients/ClientInstaller.js';
 
-// Export all installer implementations
-export { BaseInstaller } from './BaseInstaller.js';
-export { NpmInstaller } from './NpmInstaller.js';
-export { PipInstaller } from './PipInstaller.js';
-export { GeneralInstaller } from './GeneralInstaller.js';
-export { InstallerFactory, createInstallerFactory } from './InstallerFactory.js';
+// Export all requirement installer implementations
+export { BaseInstaller } from './requirements/BaseInstaller.js';
+export { NpmInstaller } from './requirements/NpmInstaller.js';
+export { PipInstaller } from './requirements/PipInstaller.js';
+export { GeneralInstaller } from './requirements/GeneralInstaller.js';
+export { CommandInstaller } from './requirements/CommandInstaller.js';
+export { InstallerFactory, createInstallerFactory } from './requirements/InstallerFactory.js';