imcp 0.0.14 → 0.0.16

package/src/core/ConfigurationProvider.ts

@@ -273,6 +273,21 @@ export class ConfigurationProvider {
         });
     }
 
+    async GetServerRequirementStatus(categoryName: string, serverName: string): Promise<RequirementStatus[]> {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.feedConfiguration) return [];
+            const serverConfig = category.feedConfiguration.mcpServers.find(s => s.name === serverName);
+            if (!serverConfig?.dependencies?.requirements) return [];
+            const requirementNames = serverConfig.dependencies.requirements.map(r => r.name);
+
+            return requirementNames
+                .map(name => category?.installationStatus?.requirementsStatus[name])
+                .filter(x => x !== undefined) as RequirementStatus[];
+        });
+    }
+
     async isServerReady(categoryName: string, serverName: string, clients: string[]): Promise<boolean> {
         return await this.withLock(async () => {
             // Inline the logic from getServerStatus and getInstallationStatus to avoid nested lock

package/src/core/InstallationService.ts

@@ -149,14 +149,9 @@ export class InstallationService {
             }
           });
 
-          // Create updated requirement config with new version
-          const updatedReqConfig: RequirementConfig = {
-            ...reqConfig,
-            version: reqToUpdate.version
-          };
 
           // For pip requirements, check if we have a stored pythonEnv
-          if (updatedReqConfig.type === 'pip' && currentStatus.pythonEnv && !options?.settings?.pythonEnv) {
+          if (reqConfig.type === 'pip' && currentStatus.pythonEnv && !options?.settings?.pythonEnv) {
             options = {
               ...options,
               settings: { ...options?.settings, pythonEnv: currentStatus.pythonEnv }
@@ -164,7 +159,7 @@ export class InstallationService {
           }
 
           // Update the requirement with options for pip environment
-          const updatedStatus = await requirementService.updateRequirement(updatedReqConfig, reqToUpdate.version, options);
+          const updatedStatus = await requirementService.updateRequirement(reqConfig, reqToUpdate.version, options);
 
           // Update requirement status
           await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {

package/src/core/MCPManager.ts

@@ -9,18 +9,24 @@ import {
   ServerCategoryListOptions,
   ServerOperationResult,
   ServerUninstallOptions,
-  InstallationStatus
+  InstallationStatus,
+  FeedConfiguration,
 } from './types.js';
+import { OperationStatus } from './onboard/OnboardStatus.js';
+import { Logger } from '../utils/logger.js';
+import { FeedOnboardService } from './onboard/FeedOnboardService.js';
 import path from 'path';
 
 export class MCPManager extends EventEmitter {
   private installationService: InstallationService;
   private configProvider: ConfigurationProvider;
+  private feedOnboardService: FeedOnboardService;
 
   constructor() {
     super();
     this.configProvider = ConfigurationProvider.getInstance();
     this.installationService = new InstallationService();
+    this.feedOnboardService = new FeedOnboardService();
   }
 
   async syncFeeds(): Promise<void> {
@@ -204,6 +210,25 @@ export class MCPManager extends EventEmitter {
     }
   }
 
+  /**
+   * Onboards a new feed configuration
+   * @param config The feed configuration to onboard
+   */
+  async onboardFeed(config: FeedConfiguration): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
+    try {
+      const result = await this.feedOnboardService.onboardFeed(config);
+      // After successful onboarding initiation, sync feeds to get the latest changes
+      // Syncing should ideally happen after the PR is merged, but for now,
+      // syncing here makes the new (pending) category available locally if needed.
+      // Consider if syncFeeds should be conditional based on operation status or handled differently.
+      await this.syncFeeds();
+      return result;
+    } catch (error) {
+      Logger.error('Failed to onboard feed in MCPManager:', error);
+      throw error; // Rethrow or handle by returning a failed OperationStatus
+    }
+  }
+
   // Type-safe event emitter methods
   emit<E extends MCPEvent>(event: E, data: MCPEventData[E]): boolean {
     return super.emit(event, data);

package/src/core/RequirementService.ts

@@ -87,7 +87,7 @@ export class RequirementService {
         // Create an updated requirement with the new version
         const updatedRequirement: RequirementConfig = {
             ...requirement,
-            version: updateVersion
+            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
         };
 
         // Install the updated version
@@ -132,7 +132,7 @@ export class RequirementService {
 
         // Validate registry configuration if provided
         if (requirement.registry) {
-            const { githubRelease, artifacts, local } = requirement.registry;
+            const { githubRelease, artifacts } = requirement.registry;
 
             // Validate GitHub release configuration
             if (githubRelease) {
@@ -151,13 +151,6 @@ export class RequirementService {
                     throw new Error('Registry URL is required for artifacts registry');
                 }
             }
-
-            // Validate local registry configuration
-            if (local) {
-                if (!local.localPath) {
-                    throw new Error('Local path is required for local registry');
-                }
-            }
         }
     }
 }

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

@@ -0,0 +1,196 @@
+import { Logger } from '../../../utils/logger.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import {
+    OperationStatus,
+    McpConfig,
+    ServerInstallOptions,
+} from '../../types.js';
+import {
+    MACRO_EXPRESSIONS,
+    MacroResolverFunctions
+} from '../../../utils/macroExpressionUtils.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Base class for client installers with shared functionality
+ */
+export abstract class BaseClientInstaller {
+    /**
+     * Generate a unique operation ID for tracking installations
+     */
+    protected generateOperationId(): string {
+        return `install-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Set up installation configuration with environment variables and arguments
+     * Handles Python environment configuration if specified
+     */
+    protected async setupInstallConfig(
+        serverConfig: McpConfig,
+        options: ServerInstallOptions
+    ): Promise<any> {
+        const finalConfig: any = { ...serverConfig.installation };
+        finalConfig.mode = serverConfig.mode;
+
+        // Handle command line arguments
+        if (options.args && options.args.length > 0) {
+            Logger.debug(`Using args from ServerInstallOptions: ${options.args.join(' ')}`);
+            finalConfig.args = options.args;
+        }
+
+        // Handle environment variables
+        const baseEnv = finalConfig.env || {};
+        const defaultEnv: Record<string, string> = {};
+        for (const [key, config] of Object.entries(baseEnv)) {
+            const envConfig = config as any;
+            if (envConfig.Default) {
+                defaultEnv[key] = envConfig.Default;
+            }
+        }
+        finalConfig.env = { ...defaultEnv, ...(options.env || {}) };
+
+        // Handle macro expressions
+        await this._resolveConfigMacros(finalConfig, options);
+
+        Logger.debug(`Final installation config: ${JSON.stringify(finalConfig)}`);
+        return finalConfig;
+    }
+
+    /**
+     * Resolves and replaces known macro expressions (e.g., ${PYTHON_PACKAGE}, ${NPMPATH}, ${BROWSER_PATH})
+     * in the provided configuration object's 'args' and 'env' properties.
+     * This method directly mutates the finalConfig object.
+     * @param finalConfig The configuration object to modify.
+     * @param options Server installation options which may contain settings like pythonEnv or npmPath.
+     */
+    private async _resolveConfigMacros(
+        finalConfig: any,
+        options: ServerInstallOptions
+    ): Promise<void> {
+        for (const macro of Object.values(MACRO_EXPRESSIONS)) {
+            const isMacroInArgs = finalConfig.args?.some((arg: string) => typeof arg === 'string' && arg.includes(macro));
+            const isMacroInEnv = Object.values(finalConfig.env || {}).some(value => typeof value === 'string' && value.includes(macro));
+
+            if (!isMacroInArgs && !isMacroInEnv) {
+                Logger.debug(`Macro ${macro} not found in args or env, skipping resolution.`);
+                continue;
+            }
+
+            const resolver = MacroResolverFunctions[macro];
+            if (resolver) {
+                const resolvedValue = await resolver(finalConfig, options);
+                if (resolvedValue !== undefined) {
+                    // Replace in args
+                    if (finalConfig.args) {
+                        const originalArgsString = finalConfig.args.join(' ');
+                        finalConfig.args = finalConfig.args.map((arg: string) =>
+                            typeof arg === 'string' && arg.includes(macro)
+                                ? arg.replace(new RegExp(macro.replace(/[${}]/g, '\\$&'), 'g'), resolvedValue)
+                                : arg
+                        );
+                        if (finalConfig.args.join(' ') !== originalArgsString) {
+                            Logger.debug(`Args after ${macro} ('${resolvedValue}') replacement: ${finalConfig.args.join(' ')}`);
+                        }
+                    }
+                    // Replace in env
+                    if (finalConfig.env) {
+                        const originalEnvJson = JSON.stringify(finalConfig.env);
+                        for (const key in finalConfig.env) {
+                            if (typeof finalConfig.env[key] === 'string' && (finalConfig.env[key] as string).includes(macro)) {
+                                finalConfig.env[key] = (finalConfig.env[key] as string).replace(new RegExp(macro.replace(/[${}]/g, '\\$&'), 'g'), resolvedValue);
+                            }
+                        }
+                        if (JSON.stringify(finalConfig.env) !== originalEnvJson) {
+                            Logger.debug(`Env after ${macro} ('${resolvedValue}') replacement: ${JSON.stringify(finalConfig.env)}`);
+                        }
+                    }
+                } else {
+                    Logger.debug(`Could not resolve value for macro: ${macro}. It will not be replaced.`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handle NPX commands for Windows platform
+     */
+    protected async handleWindowsNpx(config: any): Promise<any> {
+        if (process.platform === 'win32' && config.command === 'npx') {
+            const npmPath = await this.getNpmPath();
+            return {
+                ...config,
+                command: 'cmd',
+                args: ['/c', 'npx', ...config.args],
+                env: {
+                    ...config.env,
+                    'APPDATA': npmPath
+                }
+            };
+        }
+        return config;
+    }
+
+    /**
+     * Initialize settings object with client-specific structure
+     * Override in child classes to provide custom initialization
+     */
+    protected initializeSettings(settings: any): void {
+        if (!settings.mcpServers) {
+            settings.mcpServers = {};
+        }
+    }
+
+    /**
+     * Handle stdio mode configuration
+     * Override in child classes to provide custom stdio configuration
+     */
+    protected async handleStdioMode(settings: any, serverName: string, finalConfig: any): Promise<void> {
+        // Convert backslashes to forward slashes in args
+        if (finalConfig.args) {
+            finalConfig.args = finalConfig.args.map((arg: string) =>
+                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+            );
+        }
+        settings.mcpServers[serverName] = {
+            command: finalConfig.command,
+            args: finalConfig.args,
+            env: finalConfig.env,
+            autoApprove: [],
+            disabled: false,
+            alwaysAllow: []
+        };
+    }
+
+    /**
+     * Handle SSE mode configuration
+     * Override in child classes to provide custom SSE configuration
+     */
+    protected handleSseMode(settings: any, serverName: string, installConfig: any): void {
+        settings.mcpServers[serverName] = {
+            type: 'sse',
+            url: installConfig.url
+        };
+    }
+
+    /**
+     * Get the NPM path on Windows
+     */
+    private async getNpmPath(): Promise<string> {
+        try {
+            const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
+            return stdout.trim().replace(/\\npm\.cmd$/, '');
+        } catch (error) {
+            Logger.error('Error getting npm path:', error);
+            return 'C:\\Program Files\\nodejs';
+        }
+    }
+
+    /**
+     * Abstract methods that must be implemented by client-specific installers
+     */
+    abstract install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
+    abstract setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void>;
+}