imcp 0.0.16 → 0.0.18

package/dist/core/validators/FeedValidator.js

@@ -1,5 +1,8 @@
+import fs from 'fs/promises';
 import { serverValidatorFactory } from "./ServerValidatorFactory.js";
 import { Logger } from "../../utils/logger.js";
+import { onboardStatusManager } from "../onboard/OnboardStatusManager.js";
+import { OnboardingProcessStatus } from "../onboard/OnboardStatus.js";
 /**
  * Validates feed configurations to ensure they meet required criteria
  */
@@ -7,12 +10,16 @@ export class FeedValidator {
     /**
      * Validates a feed configuration
      * @param config The feed configuration to validate
+     * @param categoryName The name of the category (feed name) for status updates
+     * @param operationType The type of operation for status updates
      * @returns true if valid, throws error if invalid
      */
-    validate(config) {
+    async validate(config, categoryName, operationType) {
         try {
+            await onboardStatusManager.recordStep(categoryName, operationType, `Starting feed validation for '${config.name}'`);
             Logger.debug(`Validating feed configuration: ${config.name}`);
             // Validate required fields
+            await onboardStatusManager.recordStep(categoryName, operationType, `Validating required fields for '${config.name}'`);
             if (!config.name)
                 throw new Error('Feed name is required');
             if (!config.displayName)
@@ -20,11 +27,13 @@ export class FeedValidator {
             if (!config.description)
                 throw new Error('Feed description is required');
             // Validate MCP servers array
+            await onboardStatusManager.recordStep(categoryName, operationType, `Validating MCP servers array for '${config.name}'`);
             if (!Array.isArray(config.mcpServers) || config.mcpServers.length === 0) {
                 throw new Error('Feed must contain at least one MCP server');
             }
             // Validate requirements if present
             if (config.requirements) {
+                await onboardStatusManager.recordStep(categoryName, operationType, `Validating requirements for '${config.name}'`);
                 for (const req of config.requirements) {
                     if (!req.name)
                         throw new Error('Requirement name is required');
@@ -34,12 +43,14 @@ export class FeedValidator {
                         throw new Error('Requirement version is required');
                 }
             }
+            await onboardStatusManager.recordStep(categoryName, operationType, `Feed validation successful for '${config.name}'`, undefined, OnboardingProcessStatus.VALIDATING); // Still in progress until all servers validated
             Logger.debug(`Feed configuration validation successful: ${config.name}`);
             return true;
         }
         catch (error) {
-            const errorMsg = `Feed validation failed: ${error instanceof Error ? error.message : String(error)}`;
+            const errorMsg = `Feed validation failed for '${config.name}': ${error instanceof Error ? error.message : String(error)}`;
             Logger.error(errorMsg);
+            await onboardStatusManager.recordStep(categoryName, operationType, `Feed validation failed for '${config.name}'`, undefined, OnboardingProcessStatus.FAILED, errorMsg);
             throw new Error(errorMsg);
         }
     }
@@ -47,12 +58,18 @@ export class FeedValidator {
      * Validates a single MCP server configuration using the appropriate validator
      * @param server The MCP server configuration to validate
      * @param config The feed configuration containing shared requirements
+     * @param categoryName The name of the category (feed name) for status updates
+     * @param operationType The type of operation for status updates
      * @returns true if valid, throws error if invalid
      */
-    async validateServer(server, config) {
+    async validateServer(server, config, categoryName, operationType) {
+        const feedName = config.name; // categoryName is the feedName in this context
+        const serverDisplayName = server.name;
         try {
-            Logger.debug(`Validating server configuration: ${server.name}`);
+            await onboardStatusManager.recordStep(categoryName, operationType, `Starting server validation for '${serverDisplayName}' in feed '${feedName}'`, server.name);
+            Logger.debug(`Validating server configuration: ${serverDisplayName} in feed ${feedName}`);
             // Validate basic required fields
+            await onboardStatusManager.recordStep(categoryName, operationType, `Validating basic fields for server '${serverDisplayName}'`, server.name);
             if (!server.name)
                 throw new Error('Server name is required');
             if (!server.description)
@@ -61,16 +78,53 @@ export class FeedValidator {
                 throw new Error('Server mode is required');
             if (!server.installation)
                 throw new Error('Server installation configuration is required');
+            // Validate schema file existence if schemas is defined
+            if (server.schemas) {
+                await onboardStatusManager.recordStep(categoryName, operationType, `Validating schema file for server '${serverDisplayName}'`, server.name);
+                try {
+                    // Assuming server.schemas is a relative path from the project root or a path that needs to be resolved.
+                    // For now, let's assume it's relative to the feed file's location or an absolute path.
+                    // If it's relative to the feed file, we might need the feed file's path.
+                    // For simplicity, let's assume it's a path that can be directly accessed.
+                    // If the schema path is relative to the feed config file, this logic will need adjustment.
+                    // For now, we'll treat it as a path that `fs.access` can check.
+                    // It's more likely that schema paths are relative to the feed definition file itself.
+                    // However, the task description implies `server.schemas` is a path to be checked.
+                    // Let's assume for now it's a path that should exist.
+                    // If the schemas are stored within the repo, their paths would be relative to the repo root.
+                    // During validation, we might not have the repo context directly here.
+                    // This needs clarification on how schema paths are resolved during validation.
+                    // For now, we'll proceed with a direct check.
+                    // If the schema is part of the feed package, its path might be relative to the package root.
+                    // Let's assume the path is resolvable from the current working directory or is absolute.
+                    // This part might need refinement based on where schema files are expected to be.
+                    // The task implies `server.schemas` is a string path.
+                    const schemaPath = server.schemas; // This path needs to be correctly resolved.
+                    // If it's relative to the feed file, we need that context.
+                    // For now, we'll assume it's a path that can be checked.
+                    // This might be an issue if it's relative to a file not yet in the repo.
+                    // Let's assume it's a path that should be resolvable.
+                    await fs.access(schemaPath);
+                    Logger.debug(`Schema file ${schemaPath} exists for server ${serverDisplayName}`);
+                }
+                catch (fileAccessError) {
+                    throw new Error(`Schema file '${server.schemas}' not found for server '${serverDisplayName}'.`);
+                }
+            }
             // Get the appropriate validator for this server type
+            await onboardStatusManager.recordStep(categoryName, operationType, `Obtaining specific validator for server '${serverDisplayName}'`, server.name);
             const validator = serverValidatorFactory.getValidatorForServer(server);
             // Perform mode-specific validation with feed config
-            await validator.validateServer(server, config);
-            Logger.debug(`Server configuration validation successful: ${server.name}`);
+            await onboardStatusManager.recordStep(categoryName, operationType, `Performing mode-specific validation for server '${serverDisplayName}'`, server.name);
+            await validator.validateServer(server, config); // This internal call won't have status updates unless modified too
+            await onboardStatusManager.recordStep(categoryName, operationType, `Server validation successful for '${serverDisplayName}'`, server.name, OnboardingProcessStatus.VALIDATING); // Still in progress until all servers validated
+            Logger.debug(`Server configuration validation successful: ${serverDisplayName}`);
             return true;
         }
         catch (error) {
-            const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
+            const errorMsg = `Server validation failed for '${serverDisplayName}' in feed '${feedName}': ${error instanceof Error ? error.message : String(error)}`;
             Logger.error(errorMsg);
+            await onboardStatusManager.recordStep(categoryName, operationType, `Server validation failed for '${serverDisplayName}'`, server.name, OnboardingProcessStatus.FAILED, errorMsg);
             throw new Error(errorMsg);
         }
     }

package/dist/core/validators/IServerValidator.d.ts

@@ -1,4 +1,4 @@
-import { McpConfig, FeedConfiguration } from "../types.js";
+import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
 /**
  * Interface for MCP server configuration validators
  * Defines common validation operations for server configurations

package/dist/core/validators/SSEServerValidator.d.ts

@@ -1,4 +1,4 @@
-import { McpConfig, FeedConfiguration } from "../types.js";
+import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
 import { IServerValidator } from "./IServerValidator.js";
 /**
  * Validates MCP server configurations for SSE mode

package/dist/core/validators/ServerValidatorFactory.d.ts

@@ -1,4 +1,4 @@
-import { McpConfig } from "../types.js";
+import { McpConfig } from "../metadatas/types.js";
 import { IServerValidator, ValidatorType } from "./IServerValidator.js";
 /**
  * Factory class for managing server validator instances

package/dist/core/validators/StdioServerValidator.d.ts

@@ -1,4 +1,4 @@
-import { McpConfig, FeedConfiguration } from "../types.js";
+import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
 import { IServerValidator } from "./IServerValidator.js";
 /**
  * Validates MCP server configurations for stdio mode

package/dist/core/validators/StdioServerValidator.js

@@ -4,7 +4,7 @@ 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 "../constants.js";
+import { SETTINGS_DIR } from "../metadatas/constants.js";
 import path from "path";
 const execPromise = util.promisify(exec);
 /**
@@ -91,7 +91,9 @@ export class StdioServerValidator {
                 // 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)));
+                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') {
@@ -109,54 +111,104 @@ export class StdioServerValidator {
                 }
             }
             return await new Promise((resolve, reject) => {
-                Logger.debug(`Starting process with command: ${command} ${finalArgs.join(' ')}`);
-                // Set timeout for server startup test
-                const timeout = setTimeout(() => {
-                    const msg = 'Server startup test timed out after 10 seconds';
-                    Logger.error(msg);
-                    serverProcess.kill();
-                    reject(new Error(msg));
-                }, 20000);
-                // Start the server process
+                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'],
+                    stdio: ['ignore', 'pipe', 'pipe'], // stdin, stdout, stderr
                     shell: true
                 });
-                let output = '';
-                let errorOutput = '';
-                // Collect stdout
+                let stdoutData = '';
+                let stderrData = '';
+                let settled = false;
+                const cleanupAndResolve = (value) => {
+                    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) => {
+                    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) => {
-                    output += data.toString();
-                    // If we see any output, consider it a success
-                    clearTimeout(timeout);
-                    serverProcess.kill();
-                    resolve(true);
+                    const messageChunk = data.toString();
+                    stdoutData += messageChunk;
+                    Logger.debug(`Server stdout: ${messageChunk.trim()}`);
                 });
-                // Collect stderr
                 serverProcess.stderr.on('data', (data) => {
-                    errorOutput += data.toString();
+                    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()}`);
                 });
-                // Handle process exit
-                serverProcess.on('exit', (code) => {
-                    clearTimeout(timeout);
-                    if (code !== null && code !== 0) {
-                        const msg = `Server startup failed with code ${code}: ${errorOutput}`;
+                serverProcess.on('exit', (code, signal) => {
+                    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);
-                        reject(new Error(msg));
+                        cleanupAndReject(new Error(msg));
                     }
                 });
-                // Handle process error
                 serverProcess.on('error', (error) => {
-                    clearTimeout(timeout);
-                    const msg = `Server startup error: ${error.message}`;
+                    if (settled)
+                        return;
+                    const msg = `Server process failed to start or encountered an error: ${error.message}.`;
                     Logger.error(msg);
-                    reject(error);
+                    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: ${error instanceof Error ? error.message : String(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);
         }
     }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { MCPServerCategory, ServerCategoryListOptions, ServerInstallOptions, ServerUninstallOptions, ServerOperationResult, MCPConfiguration, MCPEvent, MCPEventData, RequirementConfig, RequirementStatus, RegistryConfig } from './core/types.js';
-export { MCPManager, mcpManager } from './core/MCPManager.js';
+export { MCPServerCategory, ServerCategoryListOptions, ServerInstallOptions, ServerUninstallOptions, ServerOperationResult, MCPConfiguration, MCPEvent, MCPEventData, RequirementConfig, RequirementStatus, RegistryConfig } from './core/metadatas/types.js';
+export { MCPManager, mcpManager } from './services/MCPManager.js';
 export { ServerService, serverService } from './services/ServerService.js';
-export { RequirementService, requirementService } from './core/RequirementService.js';
+export { RequirementService, requirementService } from './services/RequirementService.js';
 export { RequirementInstaller, BaseInstaller, NpmInstaller, PipInstaller, GeneralInstaller, InstallerFactory, createInstallerFactory } from './core/installers/index.js';
 export { startWebServer } from './web/server.js';
 export declare const VERSION = "0.0.1";

package/dist/index.js

@@ -1,10 +1,10 @@
 // Public types
-export { MCPEvent } from './core/types.js';
+export { MCPEvent } from './core/metadatas/types.js';
 // Core functionality
-export { MCPManager, mcpManager } from './core/MCPManager.js';
+export { MCPManager, mcpManager } from './services/MCPManager.js';
 // Services
 export { ServerService, serverService } from './services/ServerService.js';
-export { RequirementService, requirementService } from './core/RequirementService.js';
+export { RequirementService, requirementService } from './services/RequirementService.js';
 // Installer interfaces and implementations
 export { BaseInstaller, NpmInstaller, PipInstaller, GeneralInstaller, InstallerFactory, createInstallerFactory } from './core/installers/index.js';
 // Web server

package/dist/services/InstallationService.d.ts

@@ -0,0 +1,50 @@
+import { ServerInstallOptions, ServerOperationResult } from '../core/metadatas/types.js';
+/**
+ * Handles the actual installation process for an MCP server.
+ */
+export declare class InstallationService {
+    private activeInstallations;
+    private installerFactory;
+    constructor();
+    private generateOperationId;
+    /**
+     * Installs a server based on the provided options and feed configuration.
+     * @param serverName The name of the server to install.
+     * @param options The installation options.
+     * @returns A result object indicating success or failure.
+     */
+    install(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult>;
+    /**
+     * Process requirement updates specified in serverInstallOptions
+     * All updates are processed in parallel for maximum efficiency
+     * @param categoryName The category name
+     * @param serverName The server name
+     * @param requirements The requirements to update
+     */
+    private processRequirementUpdates;
+    /**
+     * Checks and installs requirements for a server if needed
+     * @param categoryName The category name
+     * @param serverName The server name
+     * @param options The installation options
+     * @returns A failure result if requirements check fails, null if requirements are satisfied
+     */
+    private checkAndInstallRequirements;
+    /**
+     * Installs requirements in background without blocking the main thread
+     * Requirements with the same order are installed in parallel
+     */
+    private installRequirementsInBackground;
+    /**
+     * Helper to update requirement status for failure case
+     */
+    private updateRequirementFailureStatus;
+    /**
+     * Helper to update requirement status for in-progress case
+     */
+    private updateRequirementProgressStatus;
+    /**
+     * Helper to update requirement status for completion case
+     */
+    private updateRequirementCompletionStatus;
+}