imcp 0.0.16 → 0.0.18

package/src/core/{ConfigurationLoader.ts → loaders/ConfigurationLoader.ts}

@@ -1,8 +1,8 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { LOCAL_FEEDS_DIR, SUPPORTED_CLIENTS } from './constants.js';
-import { Logger } from '../utils/logger.js';
-import { readJsonFile } from '../utils/clientUtils.js';
+import { LOCAL_FEEDS_DIR, SUPPORTED_CLIENTS } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { readJsonFile } from '../../utils/clientUtils.js';
 import {
     MCPConfiguration,
     MCPServerCategory,
@@ -11,7 +11,7 @@ import {
     FeedConfiguration,
     RequirementStatus,
     InstallationStatus
-} from './types.js';
+} from '../metadatas/types.js';
 
 export class ConfigurationLoader {
     /**
@@ -177,7 +177,7 @@ export class ConfigurationLoader {
     /**
      * Loads feed configurations into the MCP configuration
      */
-    static async loadFeedsIntoConfiguration(configuration: MCPConfiguration, feedFile?: string): Promise<MCPConfiguration> {
+    static async loadFeedsIntoConfiguration(configuration: MCPConfiguration, feedFile?: string, settings?: { prLink?:string, adhocServers?: string[] }): Promise<MCPConfiguration> {
         try {
             await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
             const feeds: Record<string, FeedConfiguration> = {};
@@ -186,10 +186,34 @@ export class ConfigurationLoader {
             if (feedFile) {
                 try {
                     const content = await fs.readFile(feedFile, 'utf8');
-                    const config = JSON.parse(content) as FeedConfiguration;
+                    let config = JSON.parse(content) as FeedConfiguration;
                     if (config && config.name) {
+                        // Update systemTags if feedFile is provided
+                        if (!config.systemTags) {
+                            config.systemTags = {};
+                        }
+                        config.systemTags['adhoc'] = 'true';
+
+                        // Update PullRequest if prLink is provided in settings
+                        if (settings?.prLink) {
+                            config.PullRequest = settings.prLink;
+                        }
+
+                        // Update mcpServers systemTags if adhocServers are provided in settings
+                        if (settings?.adhocServers && settings.adhocServers.length > 0 && config.mcpServers) {
+                            config.mcpServers = config.mcpServers.map(server => {
+                                if (settings.adhocServers!.includes(server.name)) {
+                                    if (!server.systemTags) {
+                                        server.systemTags = {};
+                                    }
+                                    server.systemTags['adhoc'] = 'true';
+                                }
+                                return server;
+                            });
+                        }
+
                         feeds[config.name] = config;
-                        console.log(`Loaded feed configuration from provided file: ${feedFile}`);
+                        console.log(`Loaded and processed feed configuration from provided file: ${feedFile}`);
                     }
                 } catch (error) {
                     console.log(`Error loading feed configuration from provided file ${feedFile}:`, error);

package/src/core/{ConfigurationProvider.ts → loaders/ConfigurationProvider.ts}

@@ -3,9 +3,9 @@ import path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
-import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR, SUPPORTED_CLIENTS } from './constants.js';
-import { Logger } from '../utils/logger.js';
-import { checkGithubAuth } from '../utils/githubAuth.js';
+import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR, SUPPORTED_CLIENTS } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { checkGithubAuth } from '../../utils/githubAuth.js';
 import {
     MCPConfiguration,
     MCPServerCategory,
@@ -16,7 +16,7 @@ import {
     OperationStatus,
     ClientSettings,
     McpConfig
-} from './types.js';
+} from '../metadatas/types.js';
 import { ConfigurationLoader } from './ConfigurationLoader.js';
 
 const execAsync = promisify(exec);
@@ -59,10 +59,18 @@ export class ConfigurationProvider {
         }
     }
 
-    async initialize(feedFile?: string): Promise<void> {
+    async initialize(feedFile?: string, settings?: { prLink?:string, adhocServers?: string[] }): Promise<void> {
         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 as NodeJS.ErrnoException).code !== 'ENOENT') {
+                    throw error;
+                }
+            }
 
             try {
                 try {
@@ -77,7 +85,7 @@ export class ConfigurationProvider {
                 }
 
                 // 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) {
                 Logger.error('Error during initialization', error);
@@ -327,7 +335,7 @@ export class ConfigurationProvider {
 
                 // Download latest release
                 Logger.debug('Downloading latest release...');
-                const { downloadGithubRelease } = await import('../utils/githubUtils.js');
+                const { downloadGithubRelease } = await import('../../utils/githubUtils.js');
                 const { version, downloadPath } = await downloadGithubRelease(
                     GITHUB_REPO.repoName,
                     'latest',
@@ -364,8 +372,8 @@ export class ConfigurationProvider {
         });
     }
 
-    private async loadFeedsIntoConfiguration(feedFile?: string): Promise<void> {
-        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile);
+    private async loadFeedsIntoConfiguration(feedFile?: string, settings?: { prLink?:string, adhocServers?: string[] }): Promise<void> {
+        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile, settings);
         await this.saveConfiguration();
     }
 
@@ -384,7 +392,7 @@ export class ConfigurationProvider {
     async removeServerFromClientMCPSettings(serverName: string, target?: string): Promise<void> {
         return await this.withLock(async () => {
             // Load utils in async context to avoid circular dependencies
-            const { readJsonFile, writeJsonFile } = await import('../utils/clientUtils.js');
+            const { readJsonFile, writeJsonFile } = await import('../../utils/clientUtils.js');
 
             // Filter clients if target is specified
             const clientEntries = Object.entries(SUPPORTED_CLIENTS as Record<string, ClientSettings>);

package/src/core/loaders/ServerSchemaLoader.ts

@@ -0,0 +1,117 @@
+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 { ServerSchema } from './ServerSchemaProvider.js';
+
+export class ServerSchemaLoader {
+
+    /**
+     * 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.
+     */
+    public static async loadSchema(filePath: string): Promise<ServerSchema | undefined> {
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            const schema = JSON.parse(content);
+
+            return {
+                schema: schema
+            };
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+                Logger.debug(`No schema file found at ${filePath}`);
+                return undefined;
+            }
+            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.
+     */
+    public static async loadAllDefaultSchemas(defaultFeedsDir: string, schemaMap: Map<string, Map<string, ServerSchema>>): Promise<void> {
+        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<string, ServerSchema>();
+
+                    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);
+        }
+    }
+
+    /**
+     * 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.
+     */
+    public static async loadAdhocSchemas(adhocSchemasDir: string, categoryName: string, schemaMap: Map<string, Map<string, ServerSchema>>): Promise<void> {
+        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<string, ServerSchema>();
+            }
+
+            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);
+        }
+    }
+}

package/src/core/loaders/ServerSchemaProvider.ts

@@ -0,0 +1,99 @@
+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 interface ServerSchema {
+    schema: Record<string, any>;
+}
+
+export class ServerSchemaProvider {
+    private static instance: ServerSchemaProvider;
+    private schemaMap: Map<string, Map<string, ServerSchema>>;
+    private schemaLock: Promise<void> = Promise.resolve();
+
+    private constructor() {
+        this.schemaMap = new Map();
+    }
+
+    public static getInstance(): ServerSchemaProvider {
+        if (!ServerSchemaProvider.instance) {
+            ServerSchemaProvider.instance = new ServerSchemaProvider();
+            // 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;
+    }
+
+    private async withLock<T>(operation: () => Promise<T>): Promise<T> {
+        const current = this.schemaLock;
+        let resolve: () => void;
+        this.schemaLock = new Promise<void>(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        } finally {
+            resolve!();
+        }
+    }
+
+    async initialize(adhocSchemasDir?: string): Promise<void> {
+        await this.withLock(async () => {
+            try {
+                // Create default feeds directory if it doesn't exist
+                await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR, { recursive: true });
+
+                // 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 as NodeJS.ErrnoException).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);
+                throw error;
+            }
+        });
+    }
+
+    // The actual loading methods (loadSchema, loadAllSchemas, loadAdhocSchemas) have been moved to ServerSchemaLoader.
+    // ServerSchemaProvider now delegates to ServerSchemaLoader for these operations.
+
+    async getSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined> {
+        return await this.withLock(async () => {
+            const categorySchemas = this.schemaMap.get(categoryName);
+            if (!categorySchemas) {
+                Logger.debug(`No schemas found for category ${categoryName}`);
+                return undefined;
+            }
+            const schema = categorySchemas.get(schemaFileName);
+            if (!schema) {
+                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
+            }
+            return schema;
+        });
+    }
+
+    async reloadSchemas(): Promise<void> {
+        return await this.withLock(async () => {
+            // 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
+        });
+    }
+}

package/src/core/{types.ts → metadatas/types.ts}

@@ -24,7 +24,6 @@ export interface RequirementStatus {
 export interface MCPServerStatus {
   installedStatus: Record<string, OperationStatus>; // client: installed
   name: string;
-  tags?: string[];
   error?: string;
 }
 
@@ -48,7 +47,6 @@ export interface MCPServerCategory {
   displayName: string;
   description?: string;
   type: 'local';
-  tags?: string[];
   path?: string;
   installationStatus?: InstallationStatus;
   feedConfiguration?: FeedConfiguration;
@@ -123,6 +121,7 @@ export interface McpConfig {
   dependencies?: DependencyConfig;
   schemas?: string; // Path to the schema file
   repository?: string; // Repository URL for the server
+  systemTags?: Record<string, string>; // System tags for the feed
   installation: InstallationConfig;
 }
 
@@ -151,8 +150,10 @@ export interface FeedConfiguration {
   displayName: string;
   description: string;
   repository?: string;
+  PullRequest?: string; // Optional Pull Request link
   requirements: RequirementConfig[];
   mcpServers: McpConfig[];
+  systemTags?: Record<string, string>; // System tags for the feed
 }
 
 export interface ClientSettings {