imcp 0.1.7 → 0.1.8-dev

package/src/core/loaders/SystemSettingsManager.ts

@@ -1,278 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { SETTINGS_DIR } from '../metadatas/constants.js';
-import { SystemSettings } from '../metadatas/types.js';
-import { Logger } from '../../utils/logger.js';
-import { getSystemPythonExecutablePath, getNpmExecutablePath, getBrowserPath } from '../../utils/osUtils.js';
-
-const SETTINGS_FILE_NAME = 'system_settings.json';
-const SETTINGS_FILE_PATH = path.join(SETTINGS_DIR, 'settings', SETTINGS_FILE_NAME);
-
-export class SystemSettingsManager {
-    private static instance: SystemSettingsManager;
-    private settings: SystemSettings;
-    private settingsFilePath: string;
-    private settingsLock: Promise<void> = Promise.resolve();
-
-    private constructor() {
-        this.settingsFilePath = SETTINGS_FILE_PATH;
-        this.settings = {};
-        // No await here, initialization is best-effort. Lock will protect subsequent calls.
-        this.loadSettings().catch(error => {
-            Logger.error('Failed to initialize SystemSettingsManager during construction:', error);
-            // Initialize with empty settings if load fails, defaults will be applied on first access
-            this.settings = {};
-        });
-    }
-
-    public static getInstance(): SystemSettingsManager {
-        if (!SystemSettingsManager.instance) {
-            SystemSettingsManager.instance = new SystemSettingsManager();
-        }
-        return SystemSettingsManager.instance;
-    }
-
-    private async withLock<T>(operation: () => Promise<T>): Promise<T> {
-        const currentLock = this.settingsLock;
-        let releaseLock: () => void;
-        this.settingsLock = new Promise<void>(resolve => releaseLock = resolve);
-        try {
-            await currentLock;
-            return await operation();
-        } finally {
-            releaseLock!();
-        }
-    }
-
-    // Internal method without lock
-    private async _loadSettingsInternal(): Promise<void> {
-        try {
-            await fs.mkdir(path.dirname(this.settingsFilePath), { recursive: true });
-            const data = await fs.readFile(this.settingsFilePath, 'utf-8');
-            this.settings = JSON.parse(data);
-            await this._applyDefaultsIfNeededInternal(); // Call internal version
-        } catch (error) {
-            if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-                Logger.info(`Settings file not found at ${this.settingsFilePath}. Initializing with defaults.`);
-                this.settings = {};
-                await this._applyDefaultsIfNeededInternal(); // Call internal version
-            } else {
-                Logger.error(`Error loading settings from ${this.settingsFilePath}:`, error);
-                this.settings = {};
-                await this._applyDefaultsIfNeededInternal(); // Call internal version
-            }
-        }
-    }
-
-    /**
-     * Loads settings from the file. This operation is atomic.
-     * If the settings file doesn't exist, it initializes with defaults and creates the file.
-     * @returns A promise that resolves when settings are loaded.
-     */
-    public async loadSettings(): Promise<void> {
-        return this.withLock(() => this._loadSettingsInternal());
-    }
-
-    // Internal method without lock
-    private async _applyDefaultsIfNeededInternal(): Promise<void> {
-        let updated = false;
-        const normalizePath = (p?: string) => p ? p.replace(/\\/g, '/') : undefined;
-
-        if (!this.settings.pythonEnvs) {
-            this.settings.pythonEnvs = {};
-            updated = true;
-        }
-
-        if (!this.settings.pythonEnvs["system"]) {
-            try {
-                const pythonPath = normalizePath(await getSystemPythonExecutablePath() || undefined);
-                if (pythonPath) {
-                    this.settings.pythonEnvs["system"] = pythonPath;
-                    updated = true;
-                }
-            } catch (e) {
-                Logger.warn(`Could not get default pythonEnv: ${e}`);
-            }
-        }
-
-        if (!this.settings.nodePath) {
-            try {
-                const npmExecDir = await getNpmExecutablePath();
-                let nodeExecutable = process.platform === 'win32' ? 'node.exe' : 'node';
-                const platformNodePath = process.platform === 'win32'
-                    ? path.join(npmExecDir || '', nodeExecutable)
-                    : path.join(npmExecDir || '', 'bin', nodeExecutable);
-                this.settings.nodePath = npmExecDir ? normalizePath(platformNodePath) : undefined;
-                if (this.settings.nodePath) updated = true;
-            } catch (e) {
-                Logger.warn(`Could not get default nodePath: ${e}`);
-            }
-        } else {
-            this.settings.nodePath = normalizePath(this.settings.nodePath);
-        }
-
-        if (!this.settings.browserPath) {
-            try {
-                this.settings.browserPath = normalizePath(await getBrowserPath() || undefined);
-                if (this.settings.browserPath) updated = true;
-            } catch (e) {
-                Logger.warn(`Could not get default browserPath: ${e}`);
-            }
-        } else {
-            this.settings.browserPath = normalizePath(this.settings.browserPath);
-        }
-
-        if (!this.settings.systemEnvironments) {
-            this.settings.systemEnvironments = { ...process.env } as Record<string, string>;
-            updated = true;
-        }
-        if (this.settings.userConfigurations === undefined) {
-            this.settings.userConfigurations = {};
-            updated = true;
-        }
-
-        if (updated) {
-            await this._saveSettingsInternal();
-        }
-    }
-    
-    /**
-     * Applies default values to settings if they are not already set.
-     * This operation is atomic and saves settings if defaults are applied.
-     * @returns A promise that resolves when defaults are applied and saved if necessary.
-     */
-    public async applyDefaultsIfNeeded(): Promise<void> {
-        return this.withLock(() => this._applyDefaultsIfNeededInternal());
-    }
-
-    /**
-     * Retrieves the current system settings.
-     * If settings haven't been loaded or are empty, it attempts to load them.
-     * Paths within the settings are normalized (e.g., backslashes to forward slashes).
-     * @returns A promise that resolves to the `SystemSettings` object.
-     */
-    public async getSystemSettings(): Promise<SystemSettings> {
-        // Ensure settings are loaded if they are empty.
-        if (Object.keys(this.settings).length === 0) {
-            // Use the public, locked version of loadSettings here
-            await this.loadSettings();
-        }
-        // Return a deep copy to prevent external modification of the internal state.
-        // Ensure this.settings is used, not a potentially stale local copy.
-        const settingsToReturn = JSON.parse(JSON.stringify(this.settings));
-
-        // Ensure paths are normalized when retrieved
-        const normalizedSettings = { ...settingsToReturn };
-
-        // Normalize paths in pythonEnvs
-        if (normalizedSettings.pythonEnvs) {
-            const normalizedPythonEnvs: Record<string, string> = {};
-            Object.keys(normalizedSettings.pythonEnvs).forEach(key => {
-                normalizedPythonEnvs[key] = normalizedSettings.pythonEnvs?.[key]?.replace(/\\/g, '/') || '';
-            });
-            normalizedSettings.pythonEnvs = normalizedPythonEnvs;
-        }
-
-        normalizedSettings.nodePath = normalizedSettings.nodePath?.replace(/\\/g, '/');
-        normalizedSettings.browserPath = normalizedSettings.browserPath?.replace(/\\/g, '/');
-        return normalizedSettings;
-    }
-
-    /**
-     * Creates or updates system settings with the provided partial settings.
-     * This operation is atomic and protected by a lock.
-     * It loads existing settings if not already loaded, merges the new settings,
-     * applies any necessary defaults, and then saves the updated settings.
-     * @param newSettings A `Partial<SystemSettings>` object containing the settings to update.
-     * @returns A promise that resolves to the fully updated and normalized `SystemSettings`.
-     */
-    public async createOrUpdateSystemSettings(newSettings: Partial<SystemSettings>): Promise<SystemSettings> {
-        return this.withLock(async () => {
-            // Ensure current settings are loaded before modification by calling the internal, non-locking version
-            if (Object.keys(this.settings).length === 0) {
-                await this._loadSettingsInternal();
-            }
-
-            const normalizePath = (p?: string) => p ? p.replace(/\\/g, '/') : undefined;
-
-            // Initialize pythonEnvs if it doesn't exist on the current settings
-            if (!this.settings.pythonEnvs) {
-                this.settings.pythonEnvs = {};
-            }
-
-            // Create a new settings object by merging current and new settings.
-            const updatedSettings: SystemSettings = {
-                ...this.settings, // Start with current settings
-                ...newSettings,   // Override with new settings
-                // Explicitly handle potentially undefined paths from newSettings
-                nodePath: normalizePath(newSettings.nodePath !== undefined ? newSettings.nodePath : this.settings.nodePath),
-                browserPath: normalizePath(newSettings.browserPath !== undefined ? newSettings.browserPath : this.settings.browserPath),
-                // Ensure systemEnvironments and userConfigurations are properly merged or taken from newSettings
-                systemEnvironments: newSettings.systemEnvironments !== undefined
-                    ? newSettings.systemEnvironments
-                    : this.settings.systemEnvironments, // Keep existing if not in newSettings
-                userConfigurations: newSettings.userConfigurations !== undefined
-                    ? newSettings.userConfigurations
-                    : this.settings.userConfigurations || {}, // Keep existing or default to empty
-            };
-
-            this.settings = updatedSettings;
-
-            // Call the internal, non-locking version of applyDefaultsIfNeeded
-            await this._applyDefaultsIfNeededInternal();
-            
-            // _applyDefaultsIfNeededInternal will call _saveSettingsInternal if it makes changes.
-            // However, if newSettings were provided that didn't trigger a change in _applyDefaultsIfNeededInternal
-            // (e.g., just updating an existing path), we still need to save.
-            // So, always call _saveSettingsInternal to persist all merged changes.
-            await this._saveSettingsInternal();
-
-            Logger.info('System settings updated.');
-            // getSystemSettings will handle its own locking if it needs to load.
-            return this.getSystemSettings();
-        });
-    }
-
-    /**
-     * Internal method to save settings to the file without acquiring a lock.
-     * Assumes the lock is already held by the calling public method.
-     * Normalizes paths before saving.
-     * @returns A promise that resolves when settings are written to disk.
-     */
-    private async _saveSettingsInternal(): Promise<void> {
-        try {
-            // Normalize paths before saving
-            const settingsToSave = { ...this.settings };
-            settingsToSave.nodePath = settingsToSave.nodePath?.replace(/\\/g, '/');
-            settingsToSave.browserPath = settingsToSave.browserPath?.replace(/\\/g, '/');
-
-            if (settingsToSave.pythonEnvs) {
-                const normalizedPythonEnvs: Record<string, string> = {};
-                Object.keys(settingsToSave.pythonEnvs).forEach(key => {
-                    normalizedPythonEnvs[key] = settingsToSave.pythonEnvs?.[key]?.replace(/\\/g, '/') || '';
-                });
-                settingsToSave.pythonEnvs = normalizedPythonEnvs;
-            }
-
-            await fs.mkdir(path.dirname(this.settingsFilePath), { recursive: true });
-            await fs.writeFile(this.settingsFilePath, JSON.stringify(settingsToSave, null, 2));
-            Logger.info(`System settings saved to ${this.settingsFilePath}`);
-        } catch (error) {
-            Logger.error(`Error saving settings to ${this.settingsFilePath}:`, error);
-            throw error; // Re-throw to indicate failure
-        }
-    }
-
-    /**
-     * Saves the current settings to the file. This operation is atomic and protected by a lock.
-     * Paths are normalized before saving.
-     * @returns A promise that resolves when the settings are saved.
-     */
-    public async saveSettings(): Promise<void> {
-        await this.withLock(async () => {
-            await this._saveSettingsInternal();
-        });
-    }
-}
-
-export const systemSettingsManager = SystemSettingsManager.getInstance();

package/src/core/metadatas/constants.ts

@@ -1,122 +0,0 @@
-import os from 'os';
-import path from 'path';
-
-/**
- * Defines constants used across the application.
- */
-
-/**
- * GitHub repository configuration for feeds
- */
-export const GITHUB_REPO = {
-  url: 'https://github.com/ai-microsoft/imcp-feed.git',
-  repoName: 'ai-microsoft/imcp-feed',
-  feedsPath: 'feeds',
-  feedAssetsName: 'imcp-feeds-${latest}.zip',
-};
-
-/**
- * Local settings directory path based on OS
- */
-export const SETTINGS_DIR = (() => {
-  switch (process.platform) {
-    case 'win32':
-      return path.join(os.homedir(), '.imcp');
-    default: // linux, darwin (macOS), etc.
-      return path.join(os.homedir(), '.imcp');
-  }
-})();
-
-/**
- * Local feeds directory path
- */
-export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
-
-/**
- * Path to the user information file
- */
-export const USER_INFO_PATH = path.join(SETTINGS_DIR, 'settings', 'user_info.json');
-
-/**
- * Path to the local feeds schema directory
- */
-export const LOCAL_FEEDS_SCHEMA_DIR = path.join(LOCAL_FEEDS_DIR, 'schemas');
-
-const CODE_STRORAGE_DIR = (() => {
-  switch (process.platform) {
-    case 'win32':
-      return path.join(os.homedir(), 'AppData', 'Roaming', 'Code', 'User');
-    case 'darwin': // macOS
-      return path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User');
-    default: // linux
-      return path.join(os.homedir(), '.config', 'Code', 'User');
-  }
-})();
-
-const CODE_INSIDER_STRORAGE_DIR = (() => {
-  switch (process.platform) {
-    case 'win32':
-      return path.join(os.homedir(), 'AppData', 'Roaming', 'Code - Insiders', 'User');
-    case 'darwin': // macOS
-      return path.join(os.homedir(), 'Library', 'Application Support', 'Code - Insiders', 'User');
-    default: // linux
-      return path.join(os.homedir(), '.config', 'Code - Insiders', 'User');
-  }
-})();
-
-/**
- * Supported client configurations.
- * Key: Client name (e.g., 'vscode')
- * Value: Client-specific settings or configuration details.
- * TODO: Define actual client settings structure.
- */
-export const SUPPORTED_CLIENTS: Record<string, {
-  extension: {
-    extensionId: string;
-    leastVersion?: string;
-    repository?: string;
-    assetName?: string;
-    private?: boolean;
-  };
-  codeSettingPath: string;
-  codeInsiderSettingPath: string;
-}> = {
-  'MSRooCode': {
-
-    extension: {
-      extensionId: 'microsoftai.ms-roo-cline',
-      leastVersion: '0.0.8',
-      repository: 'ai-microsoft/roo-cline',
-      assetName: 'ms-roo-cline-${version}.vsix',
-      private: true
-    },
-    codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
-    codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
-  },
-  'Cline': { /* VS Code specific settings */
-    extension: {
-      extensionId: 'saoudrizwan.claude-dev',
-    },
-    codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
-    codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
-  },
-  'GithubCopilot': { /* GitHub Copilot specific settings */
-    extension: {
-      extensionId: 'github.copilot',
-    },
-    codeSettingPath: path.join(CODE_STRORAGE_DIR, 'settings.json'),
-    codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'settings.json'),
-  },
-  // Add other supported clients here
-};
-
-/**
- * List of supported client names.
- */
-export const SUPPORTED_CLIENT_NAMES = Object.keys(SUPPORTED_CLIENTS);
-
-/**
- * Minimum time between requirement update checks (in milliseconds)
- * 10 minutes = 10 * 60 * 1000 = 600000 ms
- */
-export const UPDATE_CHECK_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes

package/src/core/metadatas/recordingConstants.ts

@@ -1,65 +0,0 @@
-/**
- * Step name constants for InstallOperationManager and step recording.
- *
- * This file defines all static step names and documents dynamic step name patterns
- * used throughout the installation and onboarding process.
- *
- * Dynamic step names are documented as template string patterns.
- */
-
-/** Step for processing all requirement updates in a batch operation. */
-export const STEP_PROCESS_REQUIREMENT_UPDATES = 'Processing all requirement updates';
-
-/** Step for checking the status of a specific requirement. */
-export const STEP_CHECKING_REQUIREMENT_STATUS = 'Checking the status of requirement';
-
-/** Step for installing requirements in the background process. */
-export const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = 'Installing requirements in the background';
-
-/** Step for running the install logic in the NugetInstaller. */
-export const STEP_NUGET_INSTALLER_INSTALL = 'Running install in NugetInstaller';
-
-/** Step for checking and installing all requirements as needed. */
-export const STEP_CHECK_AND_INSTALL_REQUIREMENTS = 'Checking and installing all requirements';
-
-/** Step for running the install logic in the CommandInstaller. */
-export const STEP_COMMAND_INSTALLER_INSTALL = 'Running install in CommandInstaller';
-
-/** Step for running the install logic in the GeneralInstaller. */
-export const STEP_GENERAL_INSTALLER_INSTALL = 'Running install in GeneralInstaller';
-
-/** Step for executing the actual installation command (npm, pip, etc.). */
-export const STEP_INSTALLATION_COMMAND_EXECUTION = 'Executing installation command for requirement';
-
-/** Step for running the install logic in the PipInstaller. */
-export const STEP_PIP_INSTALLER_INSTALL = 'Running install in PipInstaller';
-
-/** Step for processing requirement updates in the RequirementService. */
-export const STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE = 'Processing requirement updates in RequirementService';
-
-/** Step for checking if the server is ready after installation. */
-export const STEP_CHECK_SERVER_READINESS = 'Checking server readiness after installation';
-
-/** Step for running the install logic in the NpmInstaller. */
-export const STEP_NPM_INSTALLER_INSTALL = 'Running install in NpmInstaller';
-
-/** Prefix for steps that update a specific requirement. */
-export const STEP_INSTALL_REQUIREMENT_PREFIX = 'Updating requirement:';
-
-/** Prefix for steps that execute an installation command for a requirement. */
-export const STEP_INSTALL_COMMAND_PREFIX = 'Executing installation command for:';
-
-/** Step for checking and installing the VS Code extension for the client. */
-export const STEP_CHECK_VSCODE_AND_INSTALL_EXTENSION = 'Checking and installing VS Code extension for client';
-
-/** Step for setting up the installation configuration (env, args, etc.). */
-export const STEP_SETUP_INSTALLATION_CONFIG = 'Setting up installation configuration';
-
-/** Step for updating VS Code settings for the client/server. */
-export const STEP_UPDATE_VSCODE_SETTINGS = 'Updating VS Code settings for client/server';
-
-/** Step for the overall installation process of a client or server. */
-export const STEP_INSTALLATION = 'Running overall installation process';
-
-/** Step for marking the initiation of an onboarding or installation process. */
-export const STEP_INITIATED = 'Initiating onboarding or installation process';

package/src/core/metadatas/types.ts

@@ -1,202 +0,0 @@
-export enum OSType {
-  Windows = 'windows',
-  MacOS = 'macos',
-  Linux = 'linux'
-}
-
-export interface RequirementStatus {
-  name: string;
-  type: string;
-  installed: boolean;
-  inProgress?: boolean;
-  version?: string;
-  error?: string;
-  availableUpdate?: {
-    version: string;
-    message: string;
-  };
-  lastCheckTime?: string;
-  operationStatus?: OperationStatus;
-  pythonEnv?: string; // Store Python environment path for pip requirements
-  npmPath?: string; // Path to the installed npm package path
-}
-
-export interface MCPServerStatus {
-  installedStatus: Record<string, OperationStatus>; // client: installed
-  name: string;
-  error?: string;
-}
-
-export interface OperationStatus {
-  status: 'pending' | 'in-progress' | 'completed' | 'failed';
-  type: 'install' | 'uninstall' | 'update' | 'check';
-  target: 'requirement' | 'server';
-  message?: string;
-  error?: string;
-  operationId?: string; // Added to track async operations
-}
-
-export interface InstallationStatus {
-  requirementsStatus: Record<string, RequirementStatus>;
-  serversStatus: Record<string, MCPServerStatus>;
-  lastUpdated: string;
-}
-
-export interface MCPServerCategory {
-  name: string;
-  displayName: string;
-  description?: string;
-  type: 'local';
-  path?: string;
-  installationStatus?: InstallationStatus;
-  feedConfiguration?: FeedConfiguration;
-}
-
-export interface ServerCategoryListOptions {
-  local?: boolean;
-}
-
-export interface ServerOperationResult {
-  success: boolean;
-  message?: string;
-  error?: Error;
-  output?: string; // Added to capture installation logs
-  status?: OperationStatus[]; // Added to capture operation status
-}
-
-export interface MCPConfiguration {
-  localServerCategories: MCPServerCategory[];
-  feeds: Record<string, FeedConfiguration>;
-  clientMCPSettings?: Record<string, Record<string, any>>;
-}
-
-export interface ServerInstallOptions {
-  force?: boolean;
-  env?: Record<string, string>; // Environment variables for installation
-  targetClients?: string[]; // Target clients for configuration
-  requirements?: RequirementConfig[];
-  args?: string[]; // Arguments for installation
-  settings?: Record<string, any>; // Settings for installation like python env
-}
-
-export interface UpdateRequirementOptions {
-  requirementName: string;
-  updateVersion: string;
-}
-
-export interface ServerUninstallOptions {
-  removeData?: boolean;
-  targets?: string[];  // List of client targets to uninstall from
-}
-
-// Types related to server feed configuration (e.g., ai-coder-tools.json)
-export interface EnvVariableConfig {
-  Required: boolean;
-  Description: string;
-  Default?: string;
-}
-
-export interface InstallationConfig {
-  command: string;
-  args: string[]; // Can use ${packageSource} as template variable for installation path
-  env?: Record<string, EnvVariableConfig>; // Note the colon in property name
-  url?: string; // URL for sse mode
-}
-
-export interface DependencyConfig {
-  requirements?: Array<{
-    name: string;
-    version: string;
-    order?: number;
-  }>;
-  mcpServers?: Array<{
-    name: string;
-  }>;
-}
-
-export interface McpConfig {
-  name: string;
-  description: string;
-  mode: 'stdio' | 'sse'; // Currently only stdio mode is supported in ai-coder-tools
-  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;
-}
-
-export interface RegistryConfig {
-  githubRelease?: {
-    repository: string;
-    assetsName?: string; // Template string like "ai-coder-tools-${latest}.zip"
-    assetName: string; // Template string like "ai-coder-tools-${latest}.tgz"
-  };
-  artifacts?: {
-    registryUrl: string;
-    registryName: string; // Name of the registry
-  };
-}
-
-export interface RequirementConfig {
-  name: string;
-  type: 'npm' | 'pip' | 'command' | 'extension' | 'nuget' | 'other'; // Add other requirement types if needed
-  alias?: string; // Alias for the command type
-  version: string;
-  registry?: RegistryConfig;
-}
-
-export interface FeedConfiguration {
-  name: string;
-  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 {
-  codeSettingPath: string;
-  codeInsiderSettingPath: string;
-}
-
-// Events that can be emitted by the SDK
-export enum MCPEvent {
-  SERVER_INSTALLED = 'server:installed',
-  SERVER_UNINSTALLED = 'server:uninstalled',
-  SERVER_STARTED = 'server:started',
-  SERVER_STOPPED = 'server:stopped',
-  CONFIG_CHANGED = 'config:changed',
-}
-
-export interface MCPEventData {
-  [MCPEvent.SERVER_INSTALLED]: { server: MCPServerCategory };
-  [MCPEvent.SERVER_UNINSTALLED]: { serverName: string; targets?: string[] };
-  [MCPEvent.SERVER_STARTED]: { server: MCPServerCategory };
-  [MCPEvent.SERVER_STOPPED]: { serverName: string };
-  [MCPEvent.CONFIG_CHANGED]: { configuration: MCPConfiguration };
-}
-
-export interface InstallOperationStep {
-  name: string;
-  status: 'pending' | 'in-progress' | 'completed' | 'failed' | 'canceled';
-  message?: string;
-  isCritical?: boolean;
-  timestamp: string;
-}
-
-export interface InstallOperationDetails {
-  currentStep: string;
-  steps: InstallOperationStep[];
-  lastUpdated: string;
-  error?: string;
-  overallStatus: 'pending' | 'in-progress' | 'completed' | 'failed';
-}
-export interface SystemSettings {
-  pythonEnvs?: Record<string, string>;
-  nodePath?: string;
-  browserPath?: string;
-  systemEnvironments?: Record<string, string>;
-  userConfigurations?: Record<string, string>;
-}