imcp 0.1.6 → 0.1.8-dev

package/src/core/loaders/InstallOperationManager.ts

@@ -1,367 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { SETTINGS_DIR } from '../metadatas/constants.js';
-import { InstallOperationDetails, InstallOperationStep } from '../metadatas/types.js';
-import { Logger } from '../../utils/logger.js';
-
-const INSTALL_STATUS_DIR = path.join(SETTINGS_DIR, 'InstallOperationStatus');
-
-export class InstallOperationManager {
-  private installOperationStatus: Record<string, InstallOperationDetails> = {};
-  private statusLock: Promise<void> = Promise.resolve();
-  private readonly categoryName: string;
-  private readonly serverName: string;
-  private readonly statusFilePath: string;
-
-  /**
-   * 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: string, serverName: string) {
-    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.
-   */
-  private static instanceMap: Map<string, InstallOperationManager> = 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.
-   */
-  public static getInstance(categoryName: string, serverName: string): InstallOperationManager {
-    const key = `${categoryName}::${serverName}`;
-    if (!this.instanceMap.has(key)) {
-      this.instanceMap.set(key, new InstallOperationManager(categoryName, serverName));
-    }
-    return this.instanceMap.get(key)!;
-  }
-
-  private async withLock<T>(operation: () => Promise<T>): Promise<T> {
-    const current = this.statusLock;
-    let resolve: () => void;
-    this.statusLock = new Promise<void>(r => resolve = r);
-    try {
-      await current;
-      return await operation();
-    } finally {
-      resolve!();
-    }
-  }
-
-  private async loadStatuses(): Promise<void> {
-    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 as NodeJS.ErrnoException).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
-        }
-      }
-    });
-  }
-
-  private async saveStatuses(): Promise<void> {
-    await fs.mkdir(path.dirname(this.statusFilePath), { recursive: true });
-    await fs.writeFile(this.statusFilePath, JSON.stringify(this.installOperationStatus, null, 2));
-  }
-
-  private get operationKey(): string {
-    return `${this.categoryName}-${this.serverName}`;
-  }
-
-  /**
-   * Record a step for this category/server instance.
-   */
-  public async recordStep(
-    stepName: string,
-    status: 'pending' | 'in-progress' | 'completed' | 'failed',
-    message?: string
-  ): Promise<InstallOperationDetails> {
-    return await this.withLock(async () => {
-      let operationDetails = this.installOperationStatus[this.operationKey];
-
-      const newStep: InstallOperationStep = {
-        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.
-   */
-  public async resetOperation(): Promise<InstallOperationManager> {
-    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.
-   */
-  public async getDetails(): Promise<InstallOperationDetails | undefined> {
-    await this.loadStatuses(); // Ensure latest statuses are loaded
-    return this.installOperationStatus[this.operationKey];
-  }
-
-  /**
-   * Gets all operation details in this file (for this category/server).
-   */
-  public async getAllDetails(): Promise<Record<string, InstallOperationDetails>> {
-    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
-   */
-  public async markOverallStatus(status: 'completed' | 'failed', error?: string): Promise<InstallOperationDetails | undefined> {
-    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`.
-   */
-  public async recording<T>(
-    fn: () => T | Promise<T>,
-    options?: {
-      stepName?: string;
-      inProgressMessage?: string;
-      endMessage?: string | ((data: T) => string | undefined);
-      onResult?: (result: T) => boolean;
-      onError?: (error: unknown) => { result: T; message: string } | Promise<{ result: T; message: string }> | never;
-    }
-  ): Promise<T> {
-    const { stepName, inProgressMessage = 'Step in progress', endMessage, onResult = () => true, onError } = options || {};
-
-    const resolvedStepName = stepName ?? (fn.name || 'unnamedStep');
-    const getEndMessage = (data: T, fallback: string) =>
-      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 as Error)?.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 as Error)?.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
- */
-  public recordingAsync<T>(fn: () => Promise<T>, options?: {
-    stepName?: string;
-    inProgressMessage?: string;
-    endMessage?: string | ((result: T) => string);
-    onResult?: (result: T) => boolean;
-    onError?: (error: unknown) => string | Promise<string> | never;
-    onComplete?: () => void;
-  }
-  ): void {
-    const {
-      stepName,
-      inProgressMessage = 'Step in progress',
-      endMessage,
-      onResult = () => true,
-      onError,
-      onComplete,
-    } = options || {};
-
-    const resolvedStepName = stepName ?? (fn.name || 'unnamedStep');
-    const getMessage = (data: T, fallback: string) => 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 as Error)?.message || String(onErrorThrown));
-              throw onErrorThrown;
-            }
-          } else {
-            const fallback = getMessage(err, (err as Error)?.message || String(err));
-            await this.recordStep(resolvedStepName, 'failed', fallback);
-          }
-        });
-    });
-  }
-}

package/src/core/loaders/ServerSchemaLoader.ts

@@ -1,117 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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
-        });
-    }
-}