imcp 0.1.4 → 0.1.5

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
-        });
-    }
-}

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';