imcp 0.1.1 → 0.1.3

package/dist/core/loaders/InstallOperationManager.js

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

package/dist/core/loaders/SystemSettingsManager.d.ts

@@ -0,0 +1,54 @@
+import { SystemSettings } from '../metadatas/types.js';
+export declare class SystemSettingsManager {
+    private static instance;
+    private settings;
+    private settingsFilePath;
+    private settingsLock;
+    private constructor();
+    static getInstance(): SystemSettingsManager;
+    private withLock;
+    private _loadSettingsInternal;
+    /**
+     * 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.
+     */
+    loadSettings(): Promise<void>;
+    private _applyDefaultsIfNeededInternal;
+    /**
+     * 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.
+     */
+    applyDefaultsIfNeeded(): Promise<void>;
+    /**
+     * 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.
+     */
+    getSystemSettings(): Promise<SystemSettings>;
+    /**
+     * 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`.
+     */
+    createOrUpdateSystemSettings(newSettings: Partial<SystemSettings>): Promise<SystemSettings>;
+    /**
+     * 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 _saveSettingsInternal;
+    /**
+     * 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.
+     */
+    saveSettings(): Promise<void>;
+}
+export declare const systemSettingsManager: SystemSettingsManager;

package/dist/core/loaders/SystemSettingsManager.js

@@ -0,0 +1,257 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SETTINGS_DIR } from '../metadatas/constants.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 {
+    static instance;
+    settings;
+    settingsFilePath;
+    settingsLock = Promise.resolve();
+    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 = {};
+        });
+    }
+    static getInstance() {
+        if (!SystemSettingsManager.instance) {
+            SystemSettingsManager.instance = new SystemSettingsManager();
+        }
+        return SystemSettingsManager.instance;
+    }
+    async withLock(operation) {
+        const currentLock = this.settingsLock;
+        let releaseLock;
+        this.settingsLock = new Promise(resolve => releaseLock = resolve);
+        try {
+            await currentLock;
+            return await operation();
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    // Internal method without lock
+    async _loadSettingsInternal() {
+        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.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.
+     */
+    async loadSettings() {
+        return this.withLock(() => this._loadSettingsInternal());
+    }
+    // Internal method without lock
+    async _applyDefaultsIfNeededInternal() {
+        let updated = false;
+        const normalizePath = (p) => 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 };
+            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.
+     */
+    async applyDefaultsIfNeeded() {
+        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.
+     */
+    async getSystemSettings() {
+        // 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 = {};
+            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`.
+     */
+    async createOrUpdateSystemSettings(newSettings) {
+        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) => 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 = {
+                ...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.
+     */
+    async _saveSettingsInternal() {
+        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 = {};
+                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.
+     */
+    async saveSettings() {
+        await this.withLock(async () => {
+            await this._saveSettingsInternal();
+        });
+    }
+}
+export const systemSettingsManager = SystemSettingsManager.getInstance();
+//# sourceMappingURL=SystemSettingsManager.js.map

package/dist/core/metadatas/recordingConstants.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 declare const STEP_PROCESS_REQUIREMENT_UPDATES = "Processing all requirement updates";
+/** Step for checking the status of a specific requirement. */
+export declare const STEP_CHECKING_REQUIREMENT_STATUS = "Checking the status of requirement";
+/** Step for installing requirements in the background process. */
+export declare const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = "Installing requirements in the background";
+/** Step for checking and installing all requirements as needed. */
+export declare const STEP_CHECK_AND_INSTALL_REQUIREMENTS = "Checking and installing all requirements";
+/** Step for running the install logic in the CommandInstaller. */
+export declare const STEP_COMMAND_INSTALLER_INSTALL = "Running install in CommandInstaller";
+/** Step for running the install logic in the GeneralInstaller. */
+export declare const STEP_GENERAL_INSTALLER_INSTALL = "Running install in GeneralInstaller";
+/** Step for executing the actual installation command (npm, pip, etc.). */
+export declare const STEP_INSTALLATION_COMMAND_EXECUTION = "Executing installation command for requirement";
+/** Step for running the install logic in the PipInstaller. */
+export declare const STEP_PIP_INSTALLER_INSTALL = "Running install in PipInstaller";
+/** Step for processing requirement updates in the RequirementService. */
+export declare const STEP_PROCESS_REQUIREMENT_UPDATES_SERVICE = "Processing requirement updates in RequirementService";
+/** Step for checking if the server is ready after installation. */
+export declare const STEP_CHECK_SERVER_READINESS = "Checking server readiness after installation";
+/** Step for running the install logic in the NpmInstaller. */
+export declare const STEP_NPM_INSTALLER_INSTALL = "Running install in NpmInstaller";
+/** Prefix for steps that update a specific requirement. */
+export declare const STEP_INSTALL_REQUIREMENT_PREFIX = "Updating requirement:";
+/** Prefix for steps that execute an installation command for a requirement. */
+export declare const STEP_INSTALL_COMMAND_PREFIX = "Executing installation command for:";
+/** Step for checking and installing the VS Code extension for the client. */
+export declare 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 declare const STEP_SETUP_INSTALLATION_CONFIG = "Setting up installation configuration";
+/** Step for updating VS Code settings for the client/server. */
+export declare const STEP_UPDATE_VSCODE_SETTINGS = "Updating VS Code settings for client/server";
+/** Step for the overall installation process of a client or server. */
+export declare const STEP_INSTALLATION = "Running overall installation process";
+/** Step for marking the initiation of an onboarding or installation process. */
+export declare const STEP_INITIATED = "Initiating onboarding or installation process";