imcp 0.0.16 → 0.0.17

package/src/core/validators/FeedValidator.ts

@@ -1,6 +1,10 @@
-import { FeedConfiguration, McpConfig } from "../types.js";
+import fs from 'fs/promises';
+import path from 'path';
+import { FeedConfiguration, McpConfig } from "../metadatas/types.js";
 import { serverValidatorFactory } from "./ServerValidatorFactory.js";
 import { Logger } from "../../utils/logger.js";
+import { onboardStatusManager } from "../onboard/OnboardStatusManager.js";
+import { OnboardingProcessStatus, OperationType } from "../onboard/OnboardStatus.js";
 
 /**
  * Validates feed configurations to ensure they meet required criteria
@@ -9,24 +13,30 @@ 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
    */
-  public validate(config: FeedConfiguration): boolean {
+  public async validate(config: FeedConfiguration, categoryName: string, operationType: OperationType): Promise<boolean> {
     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) throw new Error('Feed display name is required');
       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');
           if (!req.type) throw new Error('Requirement type is required');
@@ -34,11 +44,13 @@ export class FeedValidator {
         }
       }
 
+      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,29 +59,73 @@ 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
    */
-  public async validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean> {
+  public async validateServer(server: McpConfig, config: FeedConfiguration, categoryName: string, operationType: OperationType): Promise<boolean> {
+    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) throw new Error('Server description is required');
       if (!server.mode) 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);
+      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
 
-      Logger.debug(`Server configuration validation successful: ${server.name}`);
+      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/src/core/validators/IServerValidator.ts

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

package/src/core/validators/SSEServerValidator.ts

@@ -1,4 +1,4 @@
-import { McpConfig, FeedConfiguration } from "../types.js";
+import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
 import { IServerValidator } from "./IServerValidator.js";
 import { Logger } from "../../utils/logger.js";
 
@@ -16,7 +16,7 @@ export class SSEServerValidator implements IServerValidator {
   public async validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean> {
     try {
       Logger.debug(`Validating SSE server configuration: ${server.name}`);
-      
+
       if (!server.installation?.url) {
         throw new Error('SSE server URL is required in installation configuration');
       }

package/src/core/validators/ServerValidatorFactory.ts

@@ -1,4 +1,4 @@
-import { McpConfig } from "../types.js";
+import { McpConfig } from "../metadatas/types.js";
 import { IServerValidator, ValidatorType } from "./IServerValidator.js";
 import { StdioServerValidator } from "./StdioServerValidator.js";
 import { SSEServerValidator } from "./SSEServerValidator.js";

package/src/core/validators/StdioServerValidator.ts

@@ -1,4 +1,4 @@
-import { McpConfig, RequirementConfig, FeedConfiguration } from "../types.js";
+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";
@@ -6,7 +6,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);
@@ -108,7 +108,10 @@ export class StdioServerValidator implements IServerValidator {
         // 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') {
         // Resolve Python package paths in arguments
@@ -125,60 +128,109 @@ export class StdioServerValidator implements IServerValidator {
       }
 
       return await new Promise<boolean>((resolve, reject) => {
-        Logger.debug(`Starting process with command: ${command} ${finalArgs.join(' ')}`);
+        Logger.debug(`Starting process for server test 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);
+        const timeoutDuration = 20000; // 20 seconds for server startup test
 
-        // Start the server process
         const serverProcess = spawn(command, finalArgs, {
-          stdio: ['ignore', 'pipe', 'pipe'],
+          stdio: ['ignore', 'pipe', 'pipe'], // stdin, stdout, stderr
           shell: true
         });
 
-        let output = '';
-        let errorOutput = '';
+        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);
 
-        // Collect stdout
         serverProcess.stdout.on('data', (data: Buffer) => {
-          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: Buffer) => {
-          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: number | null) => {
-          clearTimeout(timeout);
-          if (code !== null && code !== 0) {
-            const msg = `Server startup failed with code ${code}: ${errorOutput}`;
+        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);
-            reject(new Error(msg));
+            cleanupAndReject(new Error(msg));
           }
         });
 
-        // Handle process error
         serverProcess.on('error', (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/src/index.ts

@@ -11,14 +11,14 @@ export {
   RequirementConfig,
   RequirementStatus,
   RegistryConfig
-} from './core/types.js';
+} 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 {

package/src/{core → services}/InstallationService.ts

@@ -11,11 +11,11 @@ import {
   OperationStatus,
   RequirementStatus,
   McpConfig
-} from './types.js';
-import { RequirementInstaller, InstallerFactory, createInstallerFactory } from './installers/index.js';
-import { SUPPORTED_CLIENTS } from './constants.js';
-import { ClientInstaller } from './installers/clients/ClientInstaller.js';
-import { ConfigurationProvider } from './ConfigurationProvider.js';
+} from '../core/metadatas/types.js';
+import { RequirementInstaller, InstallerFactory, createInstallerFactory } from '../core/installers/index.js';
+import { SUPPORTED_CLIENTS } from '../core/metadatas/constants.js';
+import { ClientInstaller } from '../core/installers/clients/ClientInstaller.js';
+import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js';
 import { Logger } from '../utils/logger.js';
 
 const execPromise = util.promisify(exec);

package/src/{core → services}/MCPManager.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'events';
-import { ConfigurationProvider } from './ConfigurationProvider.js';
+import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js';
+import { ServerSchemaProvider } from '../core/loaders/ServerSchemaProvider.js';
 import { InstallationService } from './InstallationService.js';
 import {
   MCPEvent,
@@ -11,20 +12,23 @@ import {
   ServerUninstallOptions,
   InstallationStatus,
   FeedConfiguration,
-} from './types.js';
-import { OperationStatus } from './onboard/OnboardStatus.js';
+} from '../core/metadatas/types.js';
+import { OperationStatus } from '../core/onboard/OnboardStatus.js';
 import { Logger } from '../utils/logger.js';
-import { FeedOnboardService } from './onboard/FeedOnboardService.js';
+import { FeedOnboardService } from '../core/onboard/FeedOnboardService.js';
 import path from 'path';
+import { Server } from 'http';
 
 export class MCPManager extends EventEmitter {
   private installationService: InstallationService;
   private configProvider: ConfigurationProvider;
   private feedOnboardService: FeedOnboardService;
+  private schemaProvider: ServerSchemaProvider;
 
   constructor() {
     super();
     this.configProvider = ConfigurationProvider.getInstance();
+    this.schemaProvider = ServerSchemaProvider.getInstance();
     this.installationService = new InstallationService();
     this.feedOnboardService = new FeedOnboardService();
   }
@@ -33,9 +37,10 @@ export class MCPManager extends EventEmitter {
     await this.configProvider.syncFeeds();
   }
 
-  async initialize(feedFile?: string): Promise<void> {
+  async initialize(feedFile?: string, schemasDirectory?: string): Promise<void> {
     try {
       await this.configProvider.initialize(feedFile);
+      await this.schemaProvider.initialize(schemasDirectory);
     } catch (error) {
       console.error("Error during MCPManager initialization:", error);
       throw error;

package/src/{core → services}/RequirementService.ts

@@ -1,5 +1,5 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from './types.js';
-import { createInstallerFactory } from './installers/index.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../core/metadatas/types.js';
+import { createInstallerFactory } from '../core/installers/index.js';
 import { exec } from 'child_process';
 import util from 'util';
 
@@ -23,19 +23,6 @@ export class RequirementService {
         return RequirementService.instance;
     }
 
-    /**
-     * Install a requirement
-     * @param requirement The requirement to install
-     * @returns The installation status
-     */
-    public async installRequirement(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
-        // Validate requirement
-        this.validateRequirement(requirement);
-
-        // Install the requirement
-        return await this.installerFactory.install(requirement, options);
-    }
-
     /**
      * Check the installation status of a requirement
      * @param requirement The requirement to check
@@ -94,22 +81,6 @@ export class RequirementService {
         return await this.installerFactory.install(updatedRequirement, options);
     }
 
-    /**
-     * Install multiple requirements
-     * @param requirements The requirements to install
-     * @returns A map of requirement names to their installation status
-     */
-    public async installRequirements(requirements: RequirementConfig[]): Promise<Record<string, RequirementStatus>> {
-        const results: Record<string, RequirementStatus> = {};
-
-        // Process each requirement sequentially to avoid conflicts
-        for (const requirement of requirements) {
-            results[requirement.name] = await this.installRequirement(requirement);
-        }
-
-        return results;
-    }
-
     /**
      * Validate a requirement configuration
      * @param requirement The requirement to validate

package/src/services/ServerService.ts

@@ -1,7 +1,7 @@
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { Logger } from '../utils/logger.js';
-import { getServerSchemaProvider, ServerSchema } from '../core/ServerSchemaProvider.js';
+import { ServerSchema, ServerSchemaProvider } from '../core/loaders/ServerSchemaProvider.js';
 import {
   MCPServerCategory,
   ServerInstallOptions,
@@ -10,10 +10,10 @@ import {
   ServerUninstallOptions,
   FeedConfiguration,
   OperationStatus as CoreOperationStatus
-} from '../core/types.js';
-import { mcpManager } from '../core/MCPManager.js';
+} from '../core/metadatas/types.js';
+import { mcpManager } from './MCPManager.js';
 import { OperationStatus } from '../core/onboard/OnboardStatus.js';
-import { UPDATE_CHECK_INTERVAL_MS } from '../core/constants.js';
+import { UPDATE_CHECK_INTERVAL_MS } from '../core/metadatas/constants.js';
 import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -70,8 +70,8 @@ export class ServerService {
     }
 
     try {
-      const { requirementService } = await import('../core/RequirementService.js');
-      const { configProvider } = await import('../core/ConfigurationProvider.js');
+      const { requirementService } = await import('./RequirementService.js');
+      const { configProvider } = await import('../core/loaders/ConfigurationProvider.js');
 
       for (const requirement of serverCategory.feedConfiguration.requirements) {
         if (requirement.version.includes('latest')) {
@@ -132,7 +132,7 @@ export class ServerService {
    */
   async getServerSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined> {
     try {
-      const provider = await getServerSchemaProvider();
+      const provider = ServerSchemaProvider.getInstance();
       const serverMcpConfig = await mcpManager.getServerMcpConfig(categoryName, serverName);
       return await provider.getSchema(categoryName, serverMcpConfig?.schemas || `${serverName}.json`);
     } catch (error) {

package/src/utils/adoUtils.ts

@@ -1,5 +1,5 @@
-import { RequirementConfig, RegistryConfig } from '../core/types.js';
-import { SETTINGS_DIR } from '../core/constants.js';
+import { RequirementConfig, RegistryConfig } from '../core/metadatas/types.js';
+import { SETTINGS_DIR } from '../core/metadatas/constants.js';
 import { Logger } from './logger.js';
 import { exec, execSync } from 'child_process';
 import util from 'util';
@@ -183,7 +183,7 @@ export async function handleArtifact(
 export async function getArtifactLatestVersion(
     requirement: RequirementConfig,
     registry: RegistryConfig['artifacts'],
-    options?: import('../core/types.js').ServerInstallOptions, // Added import for ServerInstallOptions
+    options?: import('../core/metadatas/types.js').ServerInstallOptions, // Added import for ServerInstallOptions
     targetDir?: string // Optional target directory for npm
 ): Promise<string | undefined> {
     if (!registry || !registry.registryUrl) {

package/src/utils/feedUtils.ts

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import { Logger } from './logger.js';
-import { LOCAL_FEEDS_DIR } from '../core/constants.js';
+import { LOCAL_FEEDS_DIR } from '../core/metadatas/constants.js';
 
 /**
  * Checks if local feeds exist in the LOCAL_FEEDS_DIR
@@ -21,7 +21,7 @@ export async function hasLocalFeeds(): Promise<boolean> {
     // Check if directory contains any json files
     const files = await fs.readdir(LOCAL_FEEDS_DIR);
     const hasJsonFiles = files.some(file => file.endsWith('.json'));
-    
+
     Logger.debug(`Local feeds directory ${hasJsonFiles ? 'contains' : 'does not contain'} JSON files`);
     return hasJsonFiles;
   } catch (error) {

package/src/utils/githubUtils.ts

@@ -1,11 +1,11 @@
-import { RegistryConfig, RequirementConfig } from '../core/types.js';
+import { RegistryConfig, RequirementConfig } from '../core/metadatas/types.js';
 import { exec } from 'child_process';
 import util from 'util';
 import fs from 'fs/promises';
 import path from 'path';
 import { extractZipFile } from './clientUtils.js';
 import { Logger } from './logger.js';
-import { SETTINGS_DIR } from '../core/constants.js';
+import { SETTINGS_DIR } from '../core/metadatas/constants.js';
 
 const execAsync = util.promisify(exec);
 

package/src/utils/logger.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { SETTINGS_DIR } from '../core/constants.js';
+import { SETTINGS_DIR } from '../core/metadatas/constants.js';
 
 export class Logger {
   private static verbose = false;
@@ -56,6 +56,18 @@ export class Logger {
     await this.writeToLogFile('INFO', message);
   }
 
+  static async info(message: string): Promise<void> {
+    console.info(message);
+    await this.writeToLogFile('INFO', message);
+  }
+
+  static async warn(message: string): Promise<void> {
+    const yellowColor = '\x1b[33m';
+    const resetColor = '\x1b[0m';
+    console.warn(`${yellowColor}${message}${resetColor}`);
+    await this.writeToLogFile('WARN', message);
+  }
+
   static async debug(message: string | object): Promise<void> {
     let formattedMessage: string;
 

package/src/utils/macroExpressionUtils.ts

@@ -1,6 +1,6 @@
 import { Logger } from './logger.js';
 import { getPythonPackagePath, getSystemPythonPackageDirectory, GetBrowserPath } from './osUtils.js';
-import { ServerInstallOptions } from '../core/types.js'; // Adjusted path
+import { ServerInstallOptions } from '../core/metadatas/types.js'; // Adjusted path
 import * as fsSync from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';

package/src/utils/osUtils.ts

@@ -1,4 +1,4 @@
-import { OSType } from '../core/types.js';
+import { OSType } from '../core/metadatas/types.js';
 import os from 'os';
 import { exec } from 'child_process';
 import util from 'util';
@@ -322,7 +322,7 @@ export function getPythonPackagePath(pythonExecutablePath: string): string {
           const minorVer = parts[3].split('_')[0];
           const version = majorVer + minorVer; // Combines "3" and "13" to "313"
           const localAppData = process.env.LOCALAPPDATA;
-          
+
           if (localAppData) {
             const sitePkgsPath = path.join(
               localAppData,
@@ -333,12 +333,12 @@ export function getPythonPackagePath(pythonExecutablePath: string): string {
               'Python' + version,
               'site-packages'
             );
-            
+
             Logger.debug(`Resolved Windows Store Python site-packages path: ${sitePkgsPath}`);
             return sitePkgsPath;
           }
         }
-        
+
         Logger.debug('Could not resolve Windows Store Python site-packages path');
         // Fallback to user's site-packages
         return path.join(process.env.APPDATA || '', 'Python', 'Python3', 'site-packages');

package/src/web/contract/serverContract.ts

@@ -1,5 +1,5 @@
-import { DependencyConfig, RegistryConfig, ServerInstallOptions, EnvVariableConfig } from '../../core/types.js';
-import { ServerSchema } from '../../core/ServerSchemaProvider.js';
+import { DependencyConfig, RegistryConfig, ServerInstallOptions, EnvVariableConfig } from '../../core/metadatas/types.js';
+import { ServerSchema } from '../../core/loaders/ServerSchemaProvider.js';
 
 export interface OnboardServerConfig {
   name: string;