imcp 0.0.17 → 0.0.18

package/dist/core/loaders/ConfigurationProvider.js

@@ -43,10 +43,19 @@ export class ConfigurationProvider {
             resolve();
         }
     }
-    async initialize(feedFile) {
+    async initialize(feedFile, settings) {
         await this.withLock(async () => {
             const configDir = path.dirname(this.configPath);
             await fs.mkdir(configDir, { recursive: true });
+            // remove the old configuration file if it exists
+            try {
+                await fs.rm(this.configPath, { recursive: true, force: true });
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
             try {
                 try {
                     const config = JSON.parse(await fs.readFile(this.configPath, 'utf8'));
@@ -60,7 +69,7 @@ export class ConfigurationProvider {
                     await this.saveConfiguration();
                 }
                 // Always load feeds and client settings, whether file existed or not
-                await this.loadFeedsIntoConfiguration(feedFile);
+                await this.loadFeedsIntoConfiguration(feedFile, settings);
                 await this.loadClientMCPSettings();
             }
             catch (error) {
@@ -291,8 +300,8 @@ export class ConfigurationProvider {
             }
         });
     }
-    async loadFeedsIntoConfiguration(feedFile) {
-        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile);
+    async loadFeedsIntoConfiguration(feedFile, settings) {
+        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile, settings);
         await this.saveConfiguration();
     }
     async loadClientMCPSettings() {

package/dist/core/loaders/ServerSchemaLoader.d.ts

@@ -1,11 +1,22 @@
 import { ServerSchema } from './ServerSchemaProvider.js';
 export declare class ServerSchemaLoader {
     /**
-     * Load schema for a specific server in a category
+     * Loads a single schema file.
+     * @param filePath The absolute path to the schema file.
+     * @returns A Promise that resolves to the ServerSchema or undefined if not found or error.
      */
-    static loadSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined>;
+    static loadSchema(filePath: string): Promise<ServerSchema | undefined>;
     /**
-     * Validate schema content against expected format
+     * Loads all schemas from the default feeds directory.
+     * @param defaultFeedsDir The path to the default feeds directory.
+     * @param schemaMap The map to populate with loaded schemas.
      */
-    static validateSchema(schema: any): boolean;
+    static loadAllDefaultSchemas(defaultFeedsDir: string, schemaMap: Map<string, Map<string, ServerSchema>>): Promise<void>;
+    /**
+     * Loads schemas from an adhoc directory for a specific category.
+     * @param adhocSchemasDir The path to the adhoc schemas directory.
+     * @param categoryName The name of the category for these adhoc schemas.
+     * @param schemaMap The map to update with loaded adhoc schemas.
+     */
+    static loadAdhocSchemas(adhocSchemasDir: string, categoryName: string, schemaMap: Map<string, Map<string, ServerSchema>>): Promise<void>;
 }

package/dist/core/loaders/ServerSchemaLoader.js

@@ -1,43 +1,109 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { LOCAL_FEEDS_SCHEMA_DIR } from '../metadatas/constants.js';
 import { Logger } from '../../utils/logger.js';
 export class ServerSchemaLoader {
     /**
-     * Load schema for a specific server in a category
+     * Loads a single schema file.
+     * @param filePath The absolute path to the schema file.
+     * @returns A Promise that resolves to the ServerSchema or undefined if not found or error.
      */
-    static async loadSchema(categoryName, serverName) {
+    static async loadSchema(filePath) {
         try {
-            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, `${serverName}.json`);
-            const content = await fs.readFile(schemaPath, 'utf8');
+            const content = await fs.readFile(filePath, 'utf8');
             const schema = JSON.parse(content);
-            // Validate schema structure
-            if (!schema.version || !schema.schema) {
-                Logger.debug(`Invalid schema format for server ${serverName} in category ${categoryName}`);
-                return undefined;
-            }
             return {
                 schema: schema
             };
         }
         catch (error) {
             if (error.code === 'ENOENT') {
-                Logger.debug(`No schema file found for server ${serverName} in category ${categoryName}`);
+                Logger.debug(`No schema file found at ${filePath}`);
                 return undefined;
             }
-            Logger.error(`Error loading schema for server ${serverName} in category ${categoryName}:`, error);
-            throw error;
+            Logger.error(`Error loading schema from ${filePath}:`, error);
+            // Optionally rethrow or return undefined based on desired error handling
+            return undefined;
+        }
+    }
+    /**
+     * Loads all schemas from the default feeds directory.
+     * @param defaultFeedsDir The path to the default feeds directory.
+     * @param schemaMap The map to populate with loaded schemas.
+     */
+    static async loadAllDefaultSchemas(defaultFeedsDir, schemaMap) {
+        schemaMap.clear(); // Clear map for initial load from default directory
+        try {
+            const categoryDirs = await fs.readdir(defaultFeedsDir, { withFileTypes: true });
+            for (const categoryDir of categoryDirs) {
+                if (categoryDir.isDirectory()) {
+                    const categoryName = categoryDir.name;
+                    const categoryPath = path.join(defaultFeedsDir, categoryName);
+                    const serverFiles = await fs.readdir(categoryPath);
+                    const serverSchemas = new Map();
+                    for (const file of serverFiles) {
+                        if (file.endsWith('.json')) {
+                            try {
+                                const schemaFilePath = path.join(categoryPath, file);
+                                const schema = await this.loadSchema(schemaFilePath);
+                                if (schema) {
+                                    serverSchemas.set(file, schema); // file is serverName
+                                    Logger.debug(`Loaded schema '${file}' for category '${categoryName}' from default directory`);
+                                }
+                            }
+                            catch (error) { // Error already logged in loadSchema
+                                Logger.error(`Skipping schema file ${file} in category ${categoryName} due to loading error.`);
+                            }
+                        }
+                    }
+                    if (serverSchemas.size > 0) {
+                        schemaMap.set(categoryName, serverSchemas);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.error(`Error reading schemas from default directory ${defaultFeedsDir}:`, error);
         }
     }
     /**
-     * Validate schema content against expected format
+     * Loads schemas from an adhoc directory for a specific category.
+     * @param adhocSchemasDir The path to the adhoc schemas directory.
+     * @param categoryName The name of the category for these adhoc schemas.
+     * @param schemaMap The map to update with loaded adhoc schemas.
      */
-    static validateSchema(schema) {
-        return (typeof schema === 'object' &&
-            schema !== null &&
-            typeof schema.version === 'string' &&
-            typeof schema.schema === 'object' &&
-            schema.schema !== null);
+    static async loadAdhocSchemas(adhocSchemasDir, categoryName, schemaMap) {
+        try {
+            const serverFiles = await fs.readdir(adhocSchemasDir);
+            if (schemaMap.has(categoryName)) {
+                Logger.warn(`\x1b[33mAdhoc schema category '${categoryName}' (from dir: ${adhocSchemasDir}) conflicts with an existing category. Adhoc schemas in this category will override existing ones.\x1b[0m`);
+            }
+            let serverSchemas = schemaMap.get(categoryName);
+            if (!serverSchemas) {
+                serverSchemas = new Map();
+            }
+            for (const file of serverFiles) {
+                if (file.endsWith('.json')) {
+                    try {
+                        const schemaFilePath = path.join(adhocSchemasDir, file);
+                        const schema = await this.loadSchema(schemaFilePath);
+                        if (schema) {
+                            serverSchemas.set(file, schema); // file is serverName
+                            Logger.debug(`Loaded adhoc schema '${file}' for category '${categoryName}'`);
+                        }
+                    }
+                    catch (error) { // Error already logged in loadSchema
+                        Logger.error(`Skipping adhoc schema file ${file} in category ${categoryName} due to loading error.`);
+                    }
+                }
+            }
+            if (serverSchemas.size > 0) {
+                schemaMap.set(categoryName, serverSchemas);
+            }
+        }
+        catch (error) {
+            // This case should ideally be caught by the fs.access check in ServerSchemaProvider.initialize
+            Logger.error(`Error reading adhoc schemas from directory ${adhocSchemasDir} for category ${categoryName}:`, error);
+        }
     }
 }
 //# sourceMappingURL=ServerSchemaLoader.js.map

package/dist/core/loaders/ServerSchemaProvider.d.ts

@@ -6,12 +6,9 @@ export declare class ServerSchemaProvider {
     private schemaMap;
     private schemaLock;
     private constructor();
-    static getInstance(): Promise<ServerSchemaProvider>;
+    static getInstance(): ServerSchemaProvider;
     private withLock;
-    initialize(): Promise<void>;
-    private loadSchema;
-    private loadAllSchemas;
+    initialize(adhocSchemasDir?: string): Promise<void>;
     getSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined>;
     reloadSchemas(): Promise<void>;
 }
-export declare function getServerSchemaProvider(): Promise<ServerSchemaProvider>;

package/dist/core/loaders/ServerSchemaProvider.js

@@ -2,6 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { LOCAL_FEEDS_SCHEMA_DIR } from '../metadatas/constants.js';
 import { Logger } from '../../utils/logger.js';
+import { ServerSchemaLoader } from './ServerSchemaLoader.js';
 export class ServerSchemaProvider {
     static instance;
     schemaMap;
@@ -9,10 +10,12 @@ export class ServerSchemaProvider {
     constructor() {
         this.schemaMap = new Map();
     }
-    static async getInstance() {
+    static getInstance() {
         if (!ServerSchemaProvider.instance) {
             ServerSchemaProvider.instance = new ServerSchemaProvider();
-            await ServerSchemaProvider.instance.initialize();
+            // Initialize is now called with optional adhocSchemasDir,
+            // but getInstance is often called without it initially.
+            // The actual loading with adhoc dir will happen when MCPManager calls initialize.
         }
         return ServerSchemaProvider.instance;
     }
@@ -28,13 +31,30 @@ export class ServerSchemaProvider {
             resolve();
         }
     }
-    async initialize() {
+    async initialize(adhocSchemasDir) {
         await this.withLock(async () => {
             try {
-                // Create feeds directory if it doesn't exist
+                // Create default feeds directory if it doesn't exist
                 await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR, { recursive: true });
-                // Load all schemas from the feeds directory
-                await this.loadAllSchemas();
+                // Load all schemas from the default feeds directory
+                await ServerSchemaLoader.loadAllDefaultSchemas(LOCAL_FEEDS_SCHEMA_DIR, this.schemaMap);
+                // Load schemas from adhoc directory if provided
+                if (adhocSchemasDir) {
+                    try {
+                        await fs.access(adhocSchemasDir); // Check if directory exists
+                        const adhocCategoryName = path.basename(adhocSchemasDir);
+                        Logger.info(`Loading adhoc schemas from: ${adhocSchemasDir} for category: ${adhocCategoryName}`);
+                        await ServerSchemaLoader.loadAdhocSchemas(adhocSchemasDir, adhocCategoryName, this.schemaMap);
+                    }
+                    catch (error) {
+                        if (error.code === 'ENOENT') {
+                            Logger.warn(`Adhoc schemas directory not found: ${adhocSchemasDir}`);
+                        }
+                        else {
+                            Logger.error(`Error accessing adhoc schemas directory ${adhocSchemasDir}:`, error);
+                        }
+                    }
+                }
             }
             catch (error) {
                 Logger.error('Error during schema initialization:', error);
@@ -42,53 +62,8 @@ export class ServerSchemaProvider {
             }
         });
     }
-    async loadSchema(categoryName, schemaFileName) {
-        try {
-            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, schemaFileName);
-            const content = await fs.readFile(schemaPath, 'utf8');
-            const schema = JSON.parse(content);
-            return {
-                schema: schema
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                Logger.debug(`No schema file found for ${schemaFileName} in category ${categoryName}`);
-                return undefined;
-            }
-            Logger.error(`Error loading schema ${schemaFileName} in category ${categoryName}:`, error);
-            throw error;
-        }
-    }
-    async loadAllSchemas() {
-        this.schemaMap.clear();
-        // Read server category directories
-        const categoryDirs = await fs.readdir(LOCAL_FEEDS_SCHEMA_DIR, { withFileTypes: true });
-        for (const categoryDir of categoryDirs) {
-            if (categoryDir.isDirectory()) {
-                const categoryPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryDir.name);
-                const serverFiles = await fs.readdir(categoryPath);
-                const serverSchemas = new Map();
-                for (const file of serverFiles) {
-                    if (file.endsWith('.json')) {
-                        try {
-                            const schema = await this.loadSchema(categoryDir.name, file);
-                            if (schema) {
-                                // Store with the complete file name for direct lookup
-                                serverSchemas.set(file, schema);
-                            }
-                        }
-                        catch (error) {
-                            Logger.error(`Error loading schema for file ${file} in category ${categoryDir.name}:`, error);
-                        }
-                    }
-                }
-                if (serverSchemas.size > 0) {
-                    this.schemaMap.set(categoryDir.name, serverSchemas);
-                }
-            }
-        }
-    }
+    // The actual loading methods (loadSchema, loadAllSchemas, loadAdhocSchemas) have been moved to ServerSchemaLoader.
+    // ServerSchemaProvider now delegates to ServerSchemaLoader for these operations.
     async getSchema(categoryName, schemaFileName) {
         return await this.withLock(async () => {
             const categorySchemas = this.schemaMap.get(categoryName);
@@ -105,16 +80,11 @@ export class ServerSchemaProvider {
     }
     async reloadSchemas() {
         return await this.withLock(async () => {
-            await this.loadAllSchemas();
+            // Reloading should re-evaluate both default and any configured adhoc directory
+            // For simplicity, we assume initialize would be called again if adhoc path changes.
+            // This reload will just reload from the paths known during the last full initialize.
+            await this.initialize(); // This will re-load default and adhoc if adhocSchemasDir was set
         });
     }
 }
-// Export a lazy initialized singleton instance getter
-let initPromise = null;
-export function getServerSchemaProvider() {
-    if (!initPromise) {
-        initPromise = ServerSchemaProvider.getInstance();
-    }
-    return initPromise;
-}
 //# sourceMappingURL=ServerSchemaProvider.js.map

package/dist/core/metadatas/types.d.ts

@@ -22,7 +22,6 @@ export interface RequirementStatus {
 export interface MCPServerStatus {
     installedStatus: Record<string, OperationStatus>;
     name: string;
-    tags?: string[];
     error?: string;
 }
 export interface OperationStatus {
@@ -43,7 +42,6 @@ export interface MCPServerCategory {
     displayName: string;
     description?: string;
     type: 'local';
-    tags?: string[];
     path?: string;
     installationStatus?: InstallationStatus;
     feedConfiguration?: FeedConfiguration;
@@ -107,6 +105,7 @@ export interface McpConfig {
     dependencies?: DependencyConfig;
     schemas?: string;
     repository?: string;
+    systemTags?: Record<string, string>;
     installation: InstallationConfig;
 }
 export interface RegistryConfig {
@@ -132,8 +131,10 @@ export interface FeedConfiguration {
     displayName: string;
     description: string;
     repository?: string;
+    PullRequest?: string;
     requirements: RequirementConfig[];
     mcpServers: McpConfig[];
+    systemTags?: Record<string, string>;
 }
 export interface ClientSettings {
     codeSettingPath: string;

package/dist/core/onboard/FeedOnboardService.d.ts

@@ -5,6 +5,13 @@ import { OperationStatus } from './OnboardStatus.js';
  */
 export declare class FeedOnboardService {
     constructor();
+    /**
+     * Creates an operation ID that combines feed name and operation type.
+     * @param feedName The name of the feed.
+     * @param operationType The type of operation.
+     * @returns Combined operation ID string.
+     */
+    private createOperationId;
     /**
      * Onboard a new feed configuration
      * @param config Feed configuration to onboard
@@ -26,20 +33,15 @@ export declare class FeedOnboardService {
      * If an existing operation is found, its status is returned. Otherwise, a new operation is created and started.
      * @param config The feed configuration.
      * @param operationType The type of operation to initiate (FULL_ONBOARDING or VALIDATION_ONLY).
+     * @param serverList The list of server names to process.
      * @returns A promise that resolves to the operation status.
      */
     private _initiateOperation;
-    /**
-     * Finds an existing non-completed operation for a given feed name, server name, and operation type.
-     * @param feedName The name of the feed.
-     * @param operationType The type of operation.
-     * @returns A promise that resolves to the OnboardStatus of the existing operation, or undefined if not found.
-     */
-    private _findExistingNonCompletedOperation;
     /**
      * Performs static validation of the feed configuration.
      * @param config The feed configuration to validate.
      * @param forExistingCategory Whether this is for an existing category.
+     * @returns A promise that resolves to a list of server names to be processed.
      * @throws Error if validation fails.
      */
     private validateStaticConfig;
@@ -48,6 +50,8 @@ export declare class FeedOnboardService {
      * Updates the onboarding status to VALIDATING, then to VALIDATED or FAILED based on the validation result.
      * @param onboardingId The ID of the onboarding process.
      * @param config The feed configuration to validate.
+     * @param operationType The type of operation this validation is for.
+     * @param serverList The list of server names to validate.
      * @throws Error if validation fails, to be caught by the calling process.
      */
     private _validateFeedConfiguration;
@@ -57,6 +61,8 @@ export declare class FeedOnboardService {
      * If validation fails, the error is handled by _validateFeedConfiguration and the calling _initiateOperation method.
      * @param onboardingId The ID of the onboarding process.
      * @param config The feed configuration.
+     * @param operationType The type of operation (should be 'VALIDATION_ONLY').
+     * @param serverList The list of server names to validate.
      */
     private processValidationOnly;
     /**
@@ -65,6 +71,7 @@ export declare class FeedOnboardService {
      * Manages status updates throughout the process and handles cleanup of temporary directories.
      * @param onboardingId The ID of the onboarding process.
      * @param config The feed configuration.
+     * @param operationType The type of operation (should be 'FULL_ONBOARDING').
      * @throws Error if any step of the full onboarding process fails.
      */
     private processFullOnboarding;