imcp 0.1.3 → 0.1.5

package/src/core/validators/StdioServerValidator.ts

@@ -1,312 +0,0 @@
-import { McpConfig, RequirementConfig, FeedConfiguration } from "../metadatas/types.js";
-import { IServerValidator } from "./IServerValidator.js";
-import { Logger } from "../../utils/logger.js";
-import { createInstallerFactory } from "../installers/index.js";
-import { exec, spawn } from 'child_process';
-import util from 'util';
-import { MACRO_EXPRESSIONS, resolveNpmModulePath } from "../../utils/macroExpressionUtils.js";
-import { getSystemPythonPackageDirectory } from "../../utils/osUtils.js";
-import { SETTINGS_DIR } from "../metadatas/constants.js";
-import path from "path";
-import { InstallOperationManager } from "../loaders/InstallOperationManager.js";
-
-const execPromise = util.promisify(exec);
-
-/**
- * Validates MCP server configurations for stdio mode
- */
-export class StdioServerValidator implements IServerValidator {
-  private installerFactory = createInstallerFactory();
-
-  /**
-   * Tests if a command exists and is executable
-   * @param command The command to test
-   * @returns true if command exists and is executable
-   */
-  private async isCommandExecutable(command: string): Promise<boolean> {
-    try {
-      Logger.debug(`Testing if command is executable: ${command}`);
-      const testCmd = process.platform === 'win32' ?
-        `where ${command}` :
-        `command -v ${command}`;
-
-      await execPromise(testCmd);
-      return true;
-    } catch (error) {
-      Logger.debug(`Command not found: ${command}`);
-      return false;
-    }
-  }
-
-  /**
-   * Generates a dedicated folder path for a requirement.
-   * @param requirement The requirement configuration.
-   * @returns The path to the requirement's dedicated folder.
-   * @private
-   */
-  private _getRequirementFolderPath(requirement: RequirementConfig): string {
-    return path.join(
-      SETTINGS_DIR,
-      'onboard',
-      'npm_requirements',
-      requirement.name,
-      requirement.version.includes('latest') ? 'latest' : requirement.version);
-  }
-
-  /**
-   * Validates and installs a requirement if needed
-   * @param requirement The requirement config to validate and install
-   * @returns true if requirement is successfully installed/validated
-   */
-  private async validateRequirement(requirement: RequirementConfig, recorder: InstallOperationManager): Promise<boolean> {
-    try {
-      Logger.debug(`Validating/installing requirement: ${requirement.name}`);
-      const installer = this.installerFactory.getInstaller(requirement);
-
-      if (!installer) {
-        const msg = `No installer found for requirement type: ${requirement.type}`;
-        Logger.error(msg);
-        throw new Error(msg);
-      }
-
-      const targetDir = this._getRequirementFolderPath(requirement);
-      const status = await installer.install(requirement, recorder, { settings: { folderName: targetDir } });
-      if (!status.installed) {
-        const msg = `Failed to install requirement ${requirement.name}: ${status.error || 'Unknown error'}`;
-        Logger.error(msg);
-        throw new Error(msg);
-      }
-
-      Logger.debug(`Requirement ${requirement.name} is valid and installed`);
-      return true;
-    } catch (error) {
-      const errorMsg = `Error validating/installing requirement ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`;
-      Logger.error(errorMsg);
-      throw error instanceof Error ? error : new Error(errorMsg);
-    }
-  }
-
-  /**
-   * Tests if a server can be started successfully with proper path resolution
-   * @param command The command to start the server
-   * @param args The command line arguments
-   * @returns Promise<boolean> true if server starts successfully, false otherwise
-   * 
-   * Handles special cases:
-   * - For node commands: resolves ${NPMPATH} in arguments using resolveNpmModulePath
-   * - For python/python3 commands: resolves ${PYTHON_PACKAGE} in arguments using system Python packages
-   */
-  private async testServerStartup(command: string, args: string[], requirement?: RequirementConfig): Promise<boolean> {
-    try {
-      // Log initial command and args
-      Logger.debug(`Testing server startup with command: ${command}`);
-      Logger.debug(`Original arguments: ${args.join(' ')}`);
-
-      // Handle path resolution based on command type
-      let finalArgs = [...args];
-
-      if (command === 'node') {
-        // Resolve npm module paths in arguments
-        Logger.debug('Resolving npm module paths in arguments');
-        const npmPath = requirement ? this._getRequirementFolderPath(requirement) : undefined;
-        finalArgs = args.map(arg => arg
-          .replace(MACRO_EXPRESSIONS.NPMPATH, resolveNpmModulePath(npmPath))
-          .replace(/\\/g, '/')
-        );
-        Logger.debug(`Resolved npm arguments: ${finalArgs.join(' ')}`);
-      } else if (command === 'python' || command === 'python3') {
-        // Resolve Python package paths in arguments
-        Logger.debug('Resolving Python package paths in arguments');
-        const pythonDir = await getSystemPythonPackageDirectory();
-        if (pythonDir) {
-          finalArgs = args.map(arg => arg.includes('${PYTHON_PACKAGE}') ? arg.replace('${PYTHON_PACKAGE}', pythonDir) : arg);
-          Logger.debug(`Resolved Python arguments: ${finalArgs.join(' ')}`);
-        } else {
-          const msg = 'Could not resolve system Python package directory';
-          Logger.error(msg);
-          throw new Error(msg);
-        }
-      }
-
-      return await new Promise<boolean>((resolve, reject) => {
-        Logger.debug(`Starting process for server test with command: ${command} ${finalArgs.join(' ')}`);
-
-        const timeoutDuration = 20000; // 20 seconds for server startup test
-
-        const serverProcess = spawn(command, finalArgs, {
-          stdio: ['ignore', 'pipe', 'pipe'], // stdin, stdout, stderr
-          shell: true
-        });
-
-        let stdoutData = '';
-        let stderrData = '';
-        let settled = false;
-
-        const cleanupAndResolve = (value: boolean) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timeoutId);
-          serverProcess.stdout.removeAllListeners();
-          serverProcess.stderr.removeAllListeners();
-          serverProcess.removeAllListeners('exit');
-          serverProcess.removeAllListeners('error');
-          if (serverProcess.exitCode === null && !serverProcess.killed) {
-            serverProcess.kill();
-          }
-          resolve(value);
-        };
-
-        const cleanupAndReject = (err: Error) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timeoutId);
-          serverProcess.stdout.removeAllListeners();
-          serverProcess.stderr.removeAllListeners();
-          serverProcess.removeAllListeners('exit');
-          serverProcess.removeAllListeners('error');
-          if (serverProcess.exitCode === null && !serverProcess.killed) {
-            serverProcess.kill();
-          }
-          reject(err);
-        };
-
-        const timeoutId = setTimeout(() => {
-          if (settled) return;
-
-          if (serverProcess.exitCode === null) { // Process is still running
-            Logger.debug(`Server startup test: Process still running after ${timeoutDuration / 1000} seconds. Considering it successful.`);
-            Logger.debug(`Collected stdout:\n${stdoutData}`);
-            Logger.debug(`Collected stderr:\n${stderrData}`);
-            cleanupAndResolve(true);
-          } else {
-            // Process exited before timeout, 'exit' handler should have caught it.
-            // This is a fallback or race condition handling.
-            const msg = `Server startup test: Process exited with code ${serverProcess.exitCode} before timeout completed.`;
-            Logger.error(msg);
-            Logger.debug(`Collected stdout:\n${stdoutData}`);
-            Logger.error(`Collected stderr:\n${stderrData}`); // Log stderr as error here
-            cleanupAndReject(new Error(msg + ` Stderr: ${stderrData}`));
-          }
-        }, timeoutDuration);
-
-        serverProcess.stdout.on('data', (data: Buffer) => {
-          const messageChunk = data.toString();
-          stdoutData += messageChunk;
-          Logger.debug(`Server stdout: ${messageChunk.trim()}`);
-        });
-
-        serverProcess.stderr.on('data', (data: Buffer) => {
-          const messageChunk = data.toString();
-          stderrData += messageChunk;
-          // Log stderr, but it doesn't automatically mean failure.
-          // The exit code or an 'error' event will determine failure.
-          Logger.debug(`Server stderr: ${messageChunk.trim()}`);
-        });
-
-        serverProcess.on('exit', (code: number | null, signal: string | null) => {
-          if (settled) return;
-
-          Logger.debug(`Server process exited with code ${code}, signal: ${signal}.`);
-          Logger.debug(`Final stdout:\n${stdoutData}`);
-          Logger.debug(`Final stderr:\n${stderrData}`);
-
-          if (code === 0) {
-            cleanupAndResolve(true);
-          } else {
-            const msg = `Server process exited with non-zero code ${code} or signal ${signal}. Stderr: ${stderrData.trim()}`;
-            Logger.error(msg);
-            cleanupAndReject(new Error(msg));
-          }
-        });
-
-        serverProcess.on('error', (error: Error) => {
-          if (settled) return;
-          const msg = `Server process failed to start or encountered an error: ${error.message}.`;
-          Logger.error(msg);
-          Logger.debug(`Stdout at error:\n${stdoutData}`);
-          Logger.error(`Stderr at error:\n${stderrData}`);
-          cleanupAndReject(new Error(`${msg} Stderr: ${stderrData.trim()}`));
-        });
-      });
-    } catch (error) {
-      const msg = `Failed to test server startup (outer catch): ${error instanceof Error ? error.message : String(error)}`;
-      Logger.error(msg);
-      // Ensure the error thrown is an instance of Error
-      throw error instanceof Error ? error : new Error(msg);
-    }
-  }
-
-  /**
-   * Validates stdio-specific MCP server configuration
-   * Checks command, arguments, dependencies and required environment variables
-   * @param server The MCP server configuration to validate
-   * @param config The feed configuration containing shared requirements
-   * @returns true if valid, throws error if invalid
-   */
-  public async validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean> {
-    try {
-      Logger.debug(`Validating stdio server configuration: ${server.name}`);
-
-      // Check required installation command
-      if (!server.installation?.command) {
-        throw new Error('Server command is required in installation configuration');
-      }
-
-      // Validate server mode
-      if (server.mode !== 'stdio') {
-        throw new Error(`Invalid server mode for stdio validator: ${server.mode}`);
-      }
-
-      // Parse command and arguments
-      const fullCommand = server.installation.command;
-      const [baseCommand, ...defaultArgs] = fullCommand.split(' ');
-      const args = [...defaultArgs, ...(server.installation.args || [])];
-
-      // Validate command exists and is executable
-      const isExecutable = await this.isCommandExecutable(baseCommand);
-      if (!isExecutable) {
-        throw new Error(`Command not found or not executable: ${baseCommand}`);
-      }
-
-      // Validate required environment variables if specified
-      const envVars = server.installation.env;
-      if (envVars) {
-        for (const [name, varConfig] of Object.entries(envVars)) {
-          if (varConfig.Required && !varConfig.Default && !process.env[name]) {
-            throw new Error(`Required environment variable not set: ${name}`);
-          }
-        }
-      }
-
-      // Validate dependencies if specified
-      if (server.dependencies?.requirements) {
-        Logger.debug(`Validating ${server.dependencies.requirements.length} requirements`);
-
-        for (const req of server.dependencies.requirements) {
-          const reqConfig: RequirementConfig = config.requirements?.find(r => r.name === req.name) || {
-            name: req.name,
-            version: req.version,
-            type: 'npm' // Default to npm if not specified
-          };
-
-          const isValid = await this.validateRequirement(reqConfig, InstallOperationManager.getInstance(config.name, server.name));
-          if (!isValid) {
-            throw new Error(`Dependency validation failed for: ${req.name}`);
-          }
-        }
-      }
-      // Test server startup
-      const serverStarted = await this.testServerStartup(baseCommand, args, config.requirements?.find(r => r.type === 'npm'));
-      if (!serverStarted) {
-        throw new Error(`Failed to start server with command: ${fullCommand} ${args.join(' ')}`);
-      }
-
-      Logger.debug(`Stdio server validation successful: ${server.name}`);
-      return true;
-    } catch (error) {
-      const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
-      Logger.error(errorMsg);
-      throw new Error(errorMsg);
-    }
-  }
-}

package/src/index.ts

@@ -1,44 +0,0 @@
-// Public types
-export {
-  MCPServerCategory,
-  ServerCategoryListOptions,
-  ServerInstallOptions,
-  ServerUninstallOptions,
-  ServerOperationResult,
-  MCPConfiguration,
-  MCPEvent,
-  MCPEventData,
-  RequirementConfig,
-  RequirementStatus,
-  RegistryConfig
-} from './core/metadatas/types.js';
-
-// Core functionality
-export { MCPManager, mcpManager } from './services/MCPManager.js';
-
-// Services
-export { ServerService, serverService } from './services/ServerService.js';
-export { RequirementService, requirementService } from './services/RequirementService.js';
-
-// Installer interfaces and implementations
-export {
-  RequirementInstaller,
-  BaseInstaller,
-  NpmInstaller,
-  PipInstaller,
-  GeneralInstaller,
-  InstallerFactory,
-  createInstallerFactory
-} from './core/installers/index.js';
-
-// Web server
-export { startWebServer } from './web/server.js';
-
-// Version information
-export const VERSION = '0.0.1';
-
-// Default configuration
-export const DEFAULT_CONFIG = {
-  configPath: './config/servers.json',
-  webPort: 3000
-} as const;

package/src/services/InstallationService.ts

@@ -1,102 +0,0 @@
-import {
-  ServerInstallOptions,
-  ServerOperationResult
-} from '../core/metadatas/types.js';
-import { ClientInstaller } from '../core/installers/clients/ClientInstaller.js';
-import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js';
-import { Logger } from '../utils/logger.js';
-import { requirementService } from './RequirementService.js';
-import { InstallOperationManager } from '../core/loaders/InstallOperationManager.js';
-import * as RecordingConstants from '../core/metadatas/recordingConstants.js';
-
-/**
- * Handles the actual installation process for an MCP server.
- */
-export class InstallationService {
-
-  constructor() {
-    // Constructor is now empty after removing installerFactory initialization
-  }
-
-  /**
-   * Installs a server based on the provided options.
-   * @param categoryName The category name of the server.
-   * @param serverName The name of the server to install.
-   * @param options The installation options.
-   * @returns A result object indicating success or failure.
-   */
-  async install(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult> {
-    // Reset any previous operation status for this server before starting a new one.
-    const recoder = await InstallOperationManager.getInstance(categoryName, serverName).resetOperation();
-    const configProvider = ConfigurationProvider.getInstance();
-
-    const clients = options.targetClients || [];
-
-    // Process updates for requirements if specified in options
-    if (options.requirements && options.requirements.length > 0) {
-      recoder.recordingAsync(
-        () => requirementService.processRequirementUpdates(categoryName, serverName, options),
-        {
-          stepName: RecordingConstants.STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE,
-          onError: (error) => {
-            const errorMsg = `Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`;
-            Logger.error(errorMsg);
-            return errorMsg;
-          },
-          onComplete: () => {
-            if (clients.length === 0) recoder.markOverallStatus('completed', 'Requirement updates completed.');
-          }
-        }
-      );
-    }
-
-    if (!clients || clients.length === 0) {
-      const message = 'No clients specified for installation.';
-      return { success: true, message };
-    }
-
-    // Check if the server is already installed and ready
-    const readyMessage = 'Server and clients are already installed and ready';
-    const isReady = await recoder.recording(
-      () => configProvider.isServerReady(categoryName, serverName, clients),
-      {
-        stepName: RecordingConstants.STEP_CHECK_SERVER_READINESS,
-        inProgressMessage: 'Checking if server is already ready.',
-        endMessage: (ready: boolean) => ready ? 'Server and clients are already installed and ready' : 'Server is not ready. Proceeding with installation.',
-      }
-    )
-    if (isReady) {
-      return {
-        success: true, message: readyMessage,
-        status: [{
-          status: 'completed',
-          type: 'install',
-          target: 'server',
-          message: readyMessage,
-        }]
-      };
-    }
-
-    // Create new ClientInstaller instance for handling installation
-    const clientInstaller = new ClientInstaller(categoryName, serverName, clients);
-
-    // Check and install requirements using RequirementService
-    const requirementsResult = await requirementService.checkAndInstallRequirements(categoryName, serverName, options);
-
-    // trigger a backend requirement check
-    await requirementService.checkServerRequirementForUpdateAsync(categoryName, serverName)
-      .then(() => {
-        Logger.info(`Requirement check for ${categoryName}:${serverName} completed successfully.`);
-      })
-      .catch((error) => {
-        Logger.error(`Requirement check for ${categoryName}:${serverName} failed: ${error instanceof Error ? error.message : String(error)}`);
-      });
-
-    if (requirementsResult && !requirementsResult.success) {
-      await recoder.recordStep('RequirementInstallationCheck', 'failed', requirementsResult.error?.message || requirementsResult.message || 'Requirement installation failed.');
-      return requirementsResult;
-    }
-
-    return await clientInstaller.install(options);
-  }
-}