imcp 0.1.6 → 0.1.8-dev

package/dist/core/loaders/InstallOperationManager.js

@@ -1,311 +1,2 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { SETTINGS_DIR } from '../metadatas/constants.js';
-import { Logger } from '../../utils/logger.js';
-const INSTALL_STATUS_DIR = path.join(SETTINGS_DIR, 'InstallOperationStatus');
-export class InstallOperationManager {
-    installOperationStatus = {};
-    statusLock = Promise.resolve();
-    categoryName;
-    serverName;
-    statusFilePath;
-    /**
-     * Creates an InstallOperationManager instance for a specific category and server.
-     * @param categoryName The name of the category.
-     * @param serverName The name of the server.
-     */
-    constructor(categoryName, serverName) {
-        this.categoryName = categoryName;
-        this.serverName = serverName;
-        this.statusFilePath = path.join(INSTALL_STATUS_DIR, this.categoryName, `${this.serverName}.json`);
-        this.loadStatuses().catch(error => Logger.error('Failed to initialize InstallOperationManager:', error));
-    }
-    /**
-     * Returns an InstallOperationManager instance for the given category and server.
-     * @param categoryName The name of the category.
-     * @param serverName The name of the server.
-     */
-    static instanceMap = new Map();
-    /**
-     * Returns a cached InstallOperationManager instance for the given category and server.
-     * If an instance does not exist, it will be created and cached.
-     * @param categoryName The name of the category.
-     * @param serverName The name of the server.
-     */
-    static getInstance(categoryName, serverName) {
-        const key = `${categoryName}::${serverName}`;
-        if (!this.instanceMap.has(key)) {
-            this.instanceMap.set(key, new InstallOperationManager(categoryName, serverName));
-        }
-        return this.instanceMap.get(key);
-    }
-    async withLock(operation) {
-        const current = this.statusLock;
-        let resolve;
-        this.statusLock = new Promise(r => resolve = r);
-        try {
-            await current;
-            return await operation();
-        }
-        finally {
-            resolve();
-        }
-    }
-    async loadStatuses() {
-        await this.withLock(async () => {
-            try {
-                await fs.mkdir(path.dirname(this.statusFilePath), { recursive: true });
-                const data = await fs.readFile(this.statusFilePath, 'utf-8');
-                this.installOperationStatus = JSON.parse(data);
-            }
-            catch (error) {
-                if (error.code === 'ENOENT') {
-                    this.installOperationStatus = {};
-                    await this.saveStatuses(); // Create the file if it doesn't exist
-                }
-                else {
-                    Logger.error('Failed to load install operation statuses:', error);
-                    this.installOperationStatus = {}; // Initialize with empty statuses in case of other errors
-                }
-            }
-        });
-    }
-    async saveStatuses() {
-        await fs.mkdir(path.dirname(this.statusFilePath), { recursive: true });
-        await fs.writeFile(this.statusFilePath, JSON.stringify(this.installOperationStatus, null, 2));
-    }
-    get operationKey() {
-        return `${this.categoryName}-${this.serverName}`;
-    }
-    /**
-     * Record a step for this category/server instance.
-     */
-    async recordStep(stepName, status, message) {
-        return await this.withLock(async () => {
-            let operationDetails = this.installOperationStatus[this.operationKey];
-            const newStep = {
-                name: stepName,
-                status,
-                message,
-                timestamp: new Date().toISOString(),
-            };
-            if (!operationDetails) {
-                operationDetails = {
-                    currentStep: stepName,
-                    steps: [newStep],
-                    lastUpdated: new Date().toISOString(),
-                    error: status === 'failed' ? message : undefined,
-                    overallStatus: status === 'failed' ? 'failed' : 'in-progress',
-                };
-            }
-            else {
-                // Check for an existing unfinished step with the same name
-                const existingStepIndex = operationDetails.steps.findIndex(s => s.name === stepName && s.status !== 'completed' && s.status !== 'failed');
-                if (existingStepIndex !== -1) {
-                    // Update the existing unfinished step
-                    operationDetails.steps[existingStepIndex] = newStep;
-                }
-                else {
-                    operationDetails.steps.push(newStep);
-                }
-                operationDetails.currentStep = stepName;
-                operationDetails.lastUpdated = new Date().toISOString();
-                if (status === 'failed') {
-                    operationDetails.overallStatus = 'failed';
-                    if (!operationDetails.error) { // Store the first error
-                        operationDetails.error = message;
-                    }
-                    // Mark all in-progress steps as cancelled
-                    operationDetails.steps = operationDetails.steps.map(s => s.status === 'in-progress'
-                        ? {
-                            ...s,
-                            status: 'canceled',
-                            message: (s.message ? s.message + ' ' : '') + '[Canceled due to failure]',
-                            timestamp: new Date().toISOString(),
-                        }
-                        : s);
-                }
-                else if (status === 'completed' && stepName.toLowerCase().includes('completed')) {
-                    // Check if all steps are completed or if there are any failures
-                    const allStepsCompleted = operationDetails.steps.every(s => s.status === 'completed' || (s.name === stepName && status === 'completed'));
-                    operationDetails.overallStatus = allStepsCompleted ? 'completed' : 'in-progress';
-                    if (allStepsCompleted) {
-                        operationDetails.error = undefined; // Clear error on completion
-                    }
-                }
-                else {
-                    if (operationDetails.overallStatus !== 'failed') {
-                        operationDetails.overallStatus = 'in-progress';
-                    }
-                }
-            }
-            // Special handling for the "InstallCompleted" step or similar final step names
-            if (stepName === 'InstallCompleted') {
-                operationDetails.overallStatus = status === 'completed' ? 'completed' : 'failed';
-                if (status === 'completed')
-                    operationDetails.error = undefined;
-            }
-            this.installOperationStatus[this.operationKey] = operationDetails;
-            await this.saveStatuses();
-            return operationDetails;
-        });
-    }
-    /**
-     * Resets (deletes) the operation status for this category/server.
-     * This is useful to call before starting a new installation attempt.
-     */
-    async resetOperation() {
-        await this.withLock(async () => {
-            if (this.installOperationStatus[this.operationKey]) {
-                delete this.installOperationStatus[this.operationKey];
-                Logger.info(`Reset installation operation status for ${this.operationKey}`);
-                await this.saveStatuses();
-            }
-        });
-        return this;
-    }
-    /**
-     * Gets the details for this category/server.
-     */
-    async getDetails() {
-        await this.loadStatuses(); // Ensure latest statuses are loaded
-        return this.installOperationStatus[this.operationKey];
-    }
-    /**
-     * Gets all operation details in this file (for this category/server).
-     */
-    async getAllDetails() {
-        await this.loadStatuses();
-        return this.installOperationStatus;
-    }
-    /**
-     * Explicitly mark the overall status of an operation as 'completed' or 'failed'.
-     * This can be used to force the final state regardless of step details.
-     * @param status 'completed' or 'failed'
-     * @param error Optional error message if failed
-     */
-    async markOverallStatus(status, error) {
-        return await this.withLock(async () => {
-            const operationDetails = this.installOperationStatus[this.operationKey];
-            if (!operationDetails)
-                return undefined;
-            operationDetails.overallStatus = status;
-            operationDetails.lastUpdated = new Date().toISOString();
-            if (status === 'failed') {
-                if (error) {
-                    operationDetails.error = error;
-                }
-                // Mark all in-progress steps as cancelled
-                operationDetails.steps = operationDetails.steps.map(s => s.status === 'in-progress'
-                    ? {
-                        ...s,
-                        status: 'canceled',
-                        message: (s.message ? s.message + ' ' : '') + '[Canceled due to failure]',
-                        timestamp: new Date().toISOString(),
-                    }
-                    : s);
-            }
-            if (status === 'completed') {
-                operationDetails.error = undefined;
-            }
-            await this.saveStatuses();
-            return operationDetails;
-        });
-    }
-    /**
-     * Executes a function and records its step status as 'in-progress', 'completed', or 'failed'.
-     *
-     * Useful for wrapping tasks with consistent status tracking and flexible error handling.
-     *
-     * @template T The return type of the function being executed.
-     *
-     * @param fn The function to execute. Can be synchronous or asynchronous.
-     * @param options Optional configuration:
-     *  - stepName: Custom name for the step. Defaults to the function name or 'unnamedStep'.
-     *  - inProgressMessage: Optional message to log when the step starts.
-     *  - endMessage: Optional static string or function to generate a final message from the result or error.
-     *  - onResult: A function `(result: T) => boolean` that determines whether the step was successful. Defaults to always `true`.
-     *  - onError: Optional function `(error) => { result: T; message: string } | never` that handles an error and may return a fallback result and message, or throw.
-     *
-     * @returns A promise that resolves with the result of the function if successful, or rethrows on failure.
-     *
-     * @throws The original error or any error thrown from `onError`.
-     */
-    async recording(fn, options) {
-        const { stepName, inProgressMessage = 'Step in progress', endMessage, onResult = () => true, onError } = options || {};
-        const resolvedStepName = stepName ?? (fn.name || 'unnamedStep');
-        const getEndMessage = (data, fallback) => typeof endMessage === 'function' ? endMessage(data) || 'Step completed' : endMessage ?? fallback;
-        await this.recordStep(resolvedStepName, 'in-progress', inProgressMessage);
-        try {
-            const result = await Promise.resolve(fn());
-            const isSuccess = onResult(result);
-            await this.recordStep(resolvedStepName, isSuccess ? 'completed' : 'failed', getEndMessage(result, isSuccess ? 'Step completed successfully' : 'Step failed'));
-            return result;
-        }
-        catch (err) {
-            if (!onError) {
-                await this.recordStep(resolvedStepName, 'failed', err?.message || String(err));
-                throw err;
-            }
-            try {
-                const { result, message } = await onError(err);
-                await this.recordStep(resolvedStepName, 'failed', message);
-                return result;
-            }
-            catch (onErrorThrown) {
-                await this.recordStep(resolvedStepName, 'failed', onErrorThrown?.message || String(onErrorThrown));
-                throw onErrorThrown;
-            }
-        }
-    }
-    /**
-   * Executes an asynchronous "fire-and-forget" task and records its step status as 'in-progress', 'completed', or 'failed'.
-   *
-   * Unlike `recording`, this does not await the result — it runs the task in the background.
-   * Useful for side-effecting operations like updates or notifications where progress should be logged but not block flow.
-   *
-   * @template T The resolved type of the asynchronous task.
-   *
-   * @param fn The async function to execute.
-   * @param options Optional configuration:
-   *  - stepName: Custom name for the step. Defaults to the function name or 'unnamedStep'.
-   *  - inProgressMessage: Message to log when the step starts.
-   *  - endMessage: Static string or function to generate the final message from result or error.
-   *  - onResult: A boolean or function `(result: T) => boolean` to determine if the step is successful.
-   *  - onError: A function `(error) => string` or `Promise<string>` to handle errors and return a message.
-   *             If it throws, the error is rethrown and logged.
-   *  - onComplete: Optional callback to run after completion, regardless of success or failure.
-   *
-   * @returns void
-   */
-    recordingAsync(fn, options) {
-        const { stepName, inProgressMessage = 'Step in progress', endMessage, onResult = () => true, onError, onComplete, } = options || {};
-        const resolvedStepName = stepName ?? (fn.name || 'unnamedStep');
-        const getMessage = (data, fallback) => typeof endMessage === 'function' ? endMessage(data) : endMessage ?? fallback;
-        this.recordStep(resolvedStepName, 'in-progress', inProgressMessage).then(() => {
-            fn()
-                .then(result => {
-                const isSuccess = onResult(result);
-                const message = getMessage(result, isSuccess ? 'Step completed successfully' : 'Step failed');
-                this.recordStep(resolvedStepName, isSuccess ? 'completed' : 'failed', message).then(onComplete).catch();
-            })
-                .catch(async (err) => {
-                if (onError) {
-                    try {
-                        const errorMessage = await onError(err);
-                        await this.recordStep(resolvedStepName, 'failed', errorMessage);
-                    }
-                    catch (onErrorThrown) {
-                        await this.recordStep(resolvedStepName, 'failed', onErrorThrown?.message || String(onErrorThrown));
-                        throw onErrorThrown;
-                    }
-                }
-                else {
-                    const fallback = getMessage(err, err?.message || String(err));
-                    await this.recordStep(resolvedStepName, 'failed', fallback);
-                }
-            });
-        });
-    }
-}
+import fs from"fs/promises";import path from"path";import{SETTINGS_DIR}from"../metadatas/constants.js";import{Logger}from"../../utils/logger.js";const INSTALL_STATUS_DIR=path.join(SETTINGS_DIR,"InstallOperationStatus");export class InstallOperationManager{installOperationStatus={};statusLock=Promise.resolve();categoryName;serverName;statusFilePath;constructor(t,e){this.categoryName=t,this.serverName=e,this.statusFilePath=path.join(INSTALL_STATUS_DIR,this.categoryName,`${this.serverName}.json`),this.loadStatuses().catch((t=>Logger.error("Failed to initialize InstallOperationManager:",t)))}static instanceMap=new Map;static getInstance(t,e){const s=`${t}::${e}`;return this.instanceMap.has(s)||this.instanceMap.set(s,new InstallOperationManager(t,e)),this.instanceMap.get(s)}async withLock(t){const e=this.statusLock;let s;this.statusLock=new Promise((t=>s=t));try{return await e,await t()}finally{s()}}async loadStatuses(){await this.withLock((async()=>{try{await fs.mkdir(path.dirname(this.statusFilePath),{recursive:!0});const t=await fs.readFile(this.statusFilePath,"utf-8");this.installOperationStatus=JSON.parse(t)}catch(t){"ENOENT"===t.code?(this.installOperationStatus={},await this.saveStatuses()):(Logger.error("Failed to load install operation statuses:",t),this.installOperationStatus={})}}))}async saveStatuses(){await fs.mkdir(path.dirname(this.statusFilePath),{recursive:!0}),await fs.writeFile(this.statusFilePath,JSON.stringify(this.installOperationStatus,null,2))}get operationKey(){return`${this.categoryName}-${this.serverName}`}async recordStep(t,e,s){return await this.withLock((async()=>{let a=this.installOperationStatus[this.operationKey];const i={name:t,status:e,message:s,timestamp:(new Date).toISOString()};if(a){const r=a.steps.findIndex((e=>e.name===t&&"completed"!==e.status&&"failed"!==e.status));if(-1!==r?a.steps[r]=i:a.steps.push(i),a.currentStep=t,a.lastUpdated=(new Date).toISOString(),"failed"===e)a.overallStatus="failed",a.error||(a.error=s),a.steps=a.steps.map((t=>"in-progress"===t.status?{...t,status:"canceled",message:(t.message?t.message+" ":"")+"[Canceled due to failure]",timestamp:(new Date).toISOString()}:t));else if("completed"===e&&t.toLowerCase().includes("completed")){const s=a.steps.every((s=>"completed"===s.status||s.name===t&&"completed"===e));a.overallStatus=s?"completed":"in-progress",s&&(a.error=void 0)}else"failed"!==a.overallStatus&&(a.overallStatus="in-progress")}else a={currentStep:t,steps:[i],lastUpdated:(new Date).toISOString(),error:"failed"===e?s:void 0,overallStatus:"failed"===e?"failed":"in-progress"};return"InstallCompleted"===t&&(a.overallStatus="completed"===e?"completed":"failed","completed"===e&&(a.error=void 0)),this.installOperationStatus[this.operationKey]=a,await this.saveStatuses(),a}))}async resetOperation(){return await this.withLock((async()=>{this.installOperationStatus[this.operationKey]&&(delete this.installOperationStatus[this.operationKey],Logger.info(`Reset installation operation status for ${this.operationKey}`),await this.saveStatuses())})),this}async getDetails(){return await this.loadStatuses(),this.installOperationStatus[this.operationKey]}async getAllDetails(){return await this.loadStatuses(),this.installOperationStatus}async markOverallStatus(t,e){return await this.withLock((async()=>{const s=this.installOperationStatus[this.operationKey];if(s)return s.overallStatus=t,s.lastUpdated=(new Date).toISOString(),"failed"===t&&(e&&(s.error=e),s.steps=s.steps.map((t=>"in-progress"===t.status?{...t,status:"canceled",message:(t.message?t.message+" ":"")+"[Canceled due to failure]",timestamp:(new Date).toISOString()}:t))),"completed"===t&&(s.error=void 0),await this.saveStatuses(),s}))}async recording(t,e){const{stepName:s,inProgressMessage:a="Step in progress",endMessage:i,onResult:r=()=>!0,onError:o}=e||{},n=s??(t.name||"unnamedStep");await this.recordStep(n,"in-progress",a);try{const e=await Promise.resolve(t()),s=r(e);return await this.recordStep(n,s?"completed":"failed",(l=e,p=s?"Step completed successfully":"Step failed","function"==typeof i?i(l)||"Step completed":i??p)),e}catch(t){if(!o)throw await this.recordStep(n,"failed",t?.message||String(t)),t;try{const{result:e,message:s}=await o(t);return await this.recordStep(n,"failed",s),e}catch(t){throw await this.recordStep(n,"failed",t?.message||String(t)),t}}var l,p}recordingAsync(t,e){const{stepName:s,inProgressMessage:a="Step in progress",endMessage:i,onResult:r=()=>!0,onError:o,onComplete:n}=e||{},l=s??(t.name||"unnamedStep"),p=(t,e)=>"function"==typeof i?i(t):i??e;this.recordStep(l,"in-progress",a).then((()=>{t().then((t=>{const e=r(t),s=p(t,e?"Step completed successfully":"Step failed");this.recordStep(l,e?"completed":"failed",s).then(n).catch()})).catch((async t=>{if(o)try{const e=await o(t);await this.recordStep(l,"failed",e)}catch(t){throw await this.recordStep(l,"failed",t?.message||String(t)),t}else{const e=p(t,t?.message||String(t));await this.recordStep(l,"failed",e)}}))}))}}
 //# sourceMappingURL=InstallOperationManager.js.map

package/dist/core/loaders/InstallOperationManager.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fs","path","SETTINGS_DIR","Logger","INSTALL_STATUS_DIR","join","InstallOperationManager","installOperationStatus","statusLock","Promise","resolve","categoryName","serverName","statusFilePath","constructor","this","loadStatuses","catch","error","static","Map","getInstance","key","instanceMap","has","set","get","withLock","operation","current","r","async","mkdir","dirname","recursive","data","readFile","JSON","parse","code","saveStatuses","writeFile","stringify","operationKey","recordStep","stepName","status","message","operationDetails","newStep","name","timestamp","Date","toISOString","existingStepIndex","steps","findIndex","s","push","currentStep","lastUpdated","overallStatus","map","toLowerCase","includes","allStepsCompleted","every","undefined","resetOperation","info","getDetails","getAllDetails","markOverallStatus","recording","fn","options","inProgressMessage","endMessage","onResult","onError","resolvedStepName","result","isSuccess","fallback","err","String","onErrorThrown","recordingAsync","onComplete","getMessage","then","errorMessage"],"sources":["../../../src/core/loaders/InstallOperationManager.ts"],"mappings":"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","ignoreList":[]}

package/dist/core/loaders/ServerSchemaLoader.js

@@ -1,109 +1,2 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { Logger } from '../../utils/logger.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.
-     */
-    static async loadSchema(filePath) {
-        try {
-            const content = await fs.readFile(filePath, 'utf8');
-            const schema = JSON.parse(content);
-            return {
-                schema: schema
-            };
-        }
-        catch (error) {
-            if (error.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.
-     */
-    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);
-        }
-    }
-    /**
-     * 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 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);
-        }
-    }
-}
+import fs from"fs/promises";import path from"path";import{Logger}from"../../utils/logger.js";export class ServerSchemaLoader{static async loadSchema(r){try{const e=await fs.readFile(r,"utf8");return{schema:JSON.parse(e)}}catch(e){return"ENOENT"===e.code?void Logger.debug(`No schema file found at ${r}`):void Logger.error(`Error loading schema from ${r}:`,e)}}static async loadAllDefaultSchemas(r,e){e.clear();try{const o=await fs.readdir(r,{withFileTypes:!0});for(const a of o)if(a.isDirectory()){const o=a.name,t=path.join(r,o),c=await fs.readdir(t),i=new Map;for(const r of c)if(r.endsWith(".json"))try{const e=path.join(t,r),a=await this.loadSchema(e);a&&(i.set(r,a),Logger.debug(`Loaded schema '${r}' for category '${o}' from default directory`))}catch(e){Logger.error(`Skipping schema file ${r} in category ${o} due to loading error.`)}i.size>0&&e.set(o,i)}}catch(e){Logger.error(`Error reading schemas from default directory ${r}:`,e)}}static async loadAdhocSchemas(r,e,o){try{const a=await fs.readdir(r);o.has(e)&&Logger.warn(`Adhoc schema category '${e}' (from dir: ${r}) conflicts with an existing category. Adhoc schemas in this category will override existing ones.`);let t=o.get(e);t||(t=new Map);for(const o of a)if(o.endsWith(".json"))try{const a=path.join(r,o),c=await this.loadSchema(a);c&&(t.set(o,c),Logger.debug(`Loaded adhoc schema '${o}' for category '${e}'`))}catch(r){Logger.error(`Skipping adhoc schema file ${o} in category ${e} due to loading error.`)}t.size>0&&o.set(e,t)}catch(o){Logger.error(`Error reading adhoc schemas from directory ${r} for category ${e}:`,o)}}}
 //# sourceMappingURL=ServerSchemaLoader.js.map

package/dist/core/loaders/ServerSchemaLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fs","path","Logger","ServerSchemaLoader","loadSchema","filePath","content","readFile","schema","JSON","parse","error","code","debug","loadAllDefaultSchemas","defaultFeedsDir","schemaMap","clear","categoryDirs","readdir","withFileTypes","categoryDir","isDirectory","categoryName","name","categoryPath","join","serverFiles","serverSchemas","Map","file","endsWith","schemaFilePath","this","set","size","loadAdhocSchemas","adhocSchemasDir","has","warn","get"],"sources":["../../../src/core/loaders/ServerSchemaLoader.ts"],"mappings":"OAAOA,OAAQ,qBACRC,SAAU,cAERC,WAAc,+BAGjB,MAAOC,mBAOF,uBAAaC,CAAWC,GAC3B,IACI,MAAMC,QAAgBN,GAAGO,SAASF,EAAU,QAG5C,MAAO,CACHG,OAHWC,KAAKC,MAAMJ,GAK9B,CAAE,MAAOK,GACL,MAA8C,WAAzCA,EAAgCC,UACjCV,OAAOW,MAAM,2BAA2BR,UAG5CH,OAAOS,MAAM,6BAA6BN,KAAaM,EAG3D,CACJ,CAOO,kCAAaG,CAAsBC,EAAyBC,GAC/DA,EAAUC,QAEV,IACI,MAAMC,QAAqBlB,GAAGmB,QAAQJ,EAAiB,CAAEK,eAAe,IAExE,IAAK,MAAMC,KAAeH,EACtB,GAAIG,EAAYC,cAAe,CAC3B,MAAMC,EAAeF,EAAYG,KAC3BC,EAAexB,KAAKyB,KAAKX,EAAiBQ,GAC1CI,QAAoB3B,GAAGmB,QAAQM,GAC/BG,EAAgB,IAAIC,IAE1B,IAAK,MAAMC,KAAQH,EACf,GAAIG,EAAKC,SAAS,SACd,IACI,MAAMC,EAAiB/B,KAAKyB,KAAKD,EAAcK,GACzCtB,QAAeyB,KAAK7B,WAAW4B,GACjCxB,IACAoB,EAAcM,IAAIJ,EAAMtB,GACxBN,OAAOW,MAAM,kBAAkBiB,oBAAuBP,6BAE9D,CAAE,MAAOZ,GACLT,OAAOS,MAAM,wBAAwBmB,iBAAoBP,0BAC7D,CAGJK,EAAcO,KAAO,GACrBnB,EAAUkB,IAAIX,EAAcK,EAEpC,CAER,CAAE,MAAOjB,GACJT,OAAOS,MAAM,gDAAgDI,KAAoBJ,EACtF,CACJ,CAQO,6BAAayB,CAAiBC,EAAyBd,EAAsBP,GAChF,IACI,MAAMW,QAAoB3B,GAAGmB,QAAQkB,GAEjCrB,EAAUsB,IAAIf,IACdrB,OAAOqC,KAAK,+BAAkChB,iBAA4Bc,2GAG9E,IAAIT,EAAgBZ,EAAUwB,IAAIjB,GAC7BK,IACDA,EAAgB,IAAIC,KAGxB,IAAK,MAAMC,KAAQH,EACf,GAAIG,EAAKC,SAAS,SACd,IACI,MAAMC,EAAiB/B,KAAKyB,KAAKW,EAAiBP,GAC5CtB,QAAeyB,KAAK7B,WAAW4B,GACjCxB,IACAoB,EAAcM,IAAIJ,EAAMtB,GACxBN,OAAOW,MAAM,wBAAwBiB,oBAAuBP,MAEpE,CAAE,MAAOZ,GACLT,OAAOS,MAAM,8BAA8BmB,iBAAoBP,0BACnE,CAIJK,EAAcO,KAAO,GACrBnB,EAAUkB,IAAIX,EAAcK,EAEpC,CAAE,MAAOjB,GAELT,OAAOS,MAAM,8CAA8C0B,kBAAgCd,KAAiBZ,EAChH,CACJ","ignoreList":[]}

package/dist/core/loaders/ServerSchemaProvider.js

@@ -1,90 +1,2 @@
-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;
-    schemaLock = Promise.resolve();
-    constructor() {
-        this.schemaMap = new Map();
-    }
-    static getInstance() {
-        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;
-    }
-    async withLock(operation) {
-        const current = this.schemaLock;
-        let resolve;
-        this.schemaLock = new Promise(r => resolve = r);
-        try {
-            await current;
-            return await operation();
-        }
-        finally {
-            resolve();
-        }
-    }
-    async initialize(adhocSchemasDir) {
-        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.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, schemaFileName) {
-        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() {
-        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
-        });
-    }
-}
+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;schemaLock=Promise.resolve();constructor(){this.schemaMap=new Map}static getInstance(){return ServerSchemaProvider.instance||(ServerSchemaProvider.instance=new ServerSchemaProvider),ServerSchemaProvider.instance}async withLock(e){const a=this.schemaLock;let r;this.schemaLock=new Promise((e=>r=e));try{return await a,await e()}finally{r()}}async initialize(e){await this.withLock((async()=>{try{if(await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR,{recursive:!0}),await ServerSchemaLoader.loadAllDefaultSchemas(LOCAL_FEEDS_SCHEMA_DIR,this.schemaMap),e)try{await fs.access(e);const a=path.basename(e);Logger.info(`Loading adhoc schemas from: ${e} for category: ${a}`),await ServerSchemaLoader.loadAdhocSchemas(e,a,this.schemaMap)}catch(a){"ENOENT"===a.code?Logger.warn(`Adhoc schemas directory not found: ${e}`):Logger.error(`Error accessing adhoc schemas directory ${e}:`,a)}}catch(e){throw Logger.error("Error during schema initialization:",e),e}}))}async getSchema(e,a){return await this.withLock((async()=>{const r=this.schemaMap.get(e);if(!r)return void Logger.debug(`No schemas found for category ${e}`);const t=r.get(a);return t||Logger.debug(`Schema ${a} not found in category ${e}`),t}))}async reloadSchemas(){return await this.withLock((async()=>{await this.initialize()}))}}
 //# sourceMappingURL=ServerSchemaProvider.js.map

package/dist/core/loaders/ServerSchemaProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fs","path","LOCAL_FEEDS_SCHEMA_DIR","Logger","ServerSchemaLoader","ServerSchemaProvider","static","schemaMap","schemaLock","Promise","resolve","constructor","this","Map","getInstance","instance","withLock","operation","current","r","initialize","adhocSchemasDir","async","mkdir","recursive","loadAllDefaultSchemas","access","adhocCategoryName","basename","info","loadAdhocSchemas","error","code","warn","getSchema","categoryName","schemaFileName","categorySchemas","get","debug","schema","reloadSchemas"],"sources":["../../../src/core/loaders/ServerSchemaProvider.ts"],"mappings":"OAAOA,OAAQ,qBACRC,SAAU,cACRC,2BAA8B,mCAC9BC,WAAc,+BACdC,uBAA0B,iCAM7B,MAAOC,qBACDC,gBACAC,UACAC,WAA4BC,QAAQC,UAE5C,WAAAC,GACIC,KAAKL,UAAY,IAAIM,GACzB,CAEO,kBAAOC,GAOV,OANKT,qBAAqBU,WACtBV,qBAAqBU,SAAW,IAAIV,sBAKjCA,qBAAqBU,QAChC,CAEQ,cAAMC,CAAYC,GACtB,MAAMC,EAAUN,KAAKJ,WACrB,IAAIE,EACJE,KAAKJ,WAAa,IAAIC,SAAcU,GAAKT,EAAUS,IACnD,IAEI,aADMD,QACOD,GACjB,C,QACIP,GACJ,CACJ,CAEA,gBAAMU,CAAWC,SACPT,KAAKI,UAASM,UAChB,IAQI,SANMtB,GAAGuB,MAAMrB,uBAAwB,CAAEsB,WAAW,UAG9CpB,mBAAmBqB,sBAAsBvB,uBAAwBU,KAAKL,WAGxEc,EACA,UACUrB,GAAG0B,OAAOL,GAChB,MAAMM,EAAoB1B,KAAK2B,SAASP,GACxClB,OAAO0B,KAAK,+BAA+BR,mBAAiCM,WACtEvB,mBAAmB0B,iBAAiBT,EAAiBM,EAAmBf,KAAKL,UACvF,CAAE,MAAOwB,GACyC,WAAzCA,EAAgCC,KACjC7B,OAAO8B,KAAK,sCAAsCZ,KAElDlB,OAAO4B,MAAM,2CAA2CV,KAAoBU,EAEpF,CAER,CAAE,MAAOA,GAEL,MADA5B,OAAO4B,MAAM,sCAAuCA,GAC9CA,CACV,IAER,CAKA,eAAMG,CAAUC,EAAsBC,GAClC,aAAaxB,KAAKI,UAASM,UACvB,MAAMe,EAAkBzB,KAAKL,UAAU+B,IAAIH,GAC3C,IAAKE,EAED,YADAlC,OAAOoC,MAAM,iCAAiCJ,KAGlD,MAAMK,EAASH,EAAgBC,IAAIF,GAInC,OAHKI,GACDrC,OAAOoC,MAAM,UAAUH,2BAAwCD,KAE5DK,CAAM,GAErB,CAEA,mBAAMC,GACF,aAAa7B,KAAKI,UAASM,gBAIjBV,KAAKQ,YAAY,GAE/B","ignoreList":[]}