imcp 0.1.5 → 0.1.6

package/src/core/loaders/SystemSettingsManager.ts

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

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

@@ -0,0 +1,65 @@
+/**
+ * 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

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