Add enterprise config support via env vars & Windows registry (#491)

app/MindWork AI Studio/Tools/PluginSystem/PluginConfiguration.cs

@@ -0,0 +1,193 @@
+using AIStudio.Provider;
+using AIStudio.Settings;
+using AIStudio.Settings.DataModel;
+
+using Lua;
+
+using Host = AIStudio.Provider.SelfHosted.Host;
+using Model = AIStudio.Provider.Model;
+
+namespace AIStudio.Tools.PluginSystem;
+
+public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginType type) : PluginBase(isInternal, state, type)
+{
+    private static string TB(string fallbackEN) => I18N.I.T(fallbackEN, typeof(PluginConfiguration).Namespace, nameof(PluginConfiguration));
+    private static readonly ILogger<PluginConfiguration> LOGGER = Program.LOGGER_FACTORY.CreateLogger<PluginConfiguration>();
+    private static readonly SettingsLocker SETTINGS_LOCKER = Program.SERVICE_PROVIDER.GetRequiredService<SettingsLocker>();
+    private static readonly SettingsManager SETTINGS_MANAGER = Program.SERVICE_PROVIDER.GetRequiredService<SettingsManager>();
+
+    public async Task InitializeAsync()
+    {
+        if(!this.TryProcessConfiguration(out var issue))
+            this.pluginIssues.Add(issue);
+        
+        await SETTINGS_MANAGER.StoreSettings();
+        await MessageBus.INSTANCE.SendMessage<bool>(null, Event.CONFIGURATION_CHANGED);
+    }
+    
+    /// <summary>
+    /// Tries to initialize the UI text content of the plugin.
+    /// </summary>
+    /// <param name="message">The error message, when the UI text content could not be read.</param>
+    /// <returns>True, when the UI text content could be read successfully.</returns>
+    private bool TryProcessConfiguration(out string message)
+    {
+        // Ensure that the main CONFIG table exists and is a valid Lua table:
+        if (!this.state.Environment["CONFIG"].TryRead<LuaTable>(out var mainTable))
+        {
+            message = TB("The CONFIG table does not exist or is not a valid table.");
+            return false;
+        }
+        
+        //
+        // Configured settings
+        //
+        if (!mainTable.TryGetValue("SETTINGS", out var settingsValue) || !settingsValue.TryRead<LuaTable>(out var settingsTable))
+        {
+            message = TB("The SETTINGS table does not exist or is not a valid table.");
+            return false;
+        }
+
+        if (settingsTable.TryGetValue("DataApp.UpdateBehavior", out var updateBehaviorValue) && updateBehaviorValue.TryRead<string>(out var updateBehaviorText) && Enum.TryParse<UpdateBehavior>(updateBehaviorText, true, out var updateBehavior))
+        {
+            SETTINGS_LOCKER.Register<DataApp>(x => x.UpdateBehavior, this.Id);
+            SETTINGS_MANAGER.ConfigurationData.App.UpdateBehavior = updateBehavior;
+        }
+
+        //
+        // Configured providers
+        //
+        if (!mainTable.TryGetValue("LLM_PROVIDERS", out var providersValue) || !providersValue.TryRead<LuaTable>(out var providersTable))
+        {
+            message = TB("The LLM_PROVIDERS table does not exist or is not a valid table.");
+            return false;
+        }
+
+        message = string.Empty;
+        var numberProviders = providersTable.ArrayLength;
+        var configuredProviders = new List<Settings.Provider>(numberProviders);
+        for (var i = 1; i <= numberProviders; i++)
+        {
+            var providerLuaTableValue = providersTable[i];
+            if (!providerLuaTableValue.TryRead<LuaTable>(out var providerLuaTable))
+            {
+                LOGGER.LogWarning($"The LLM_PROVIDERS table at index {i} is not a valid table.");
+                continue;
+            }
+            
+            if(this.TryReadProviderTable(i, providerLuaTable, out var provider))
+                configuredProviders.Add(provider);
+            else
+                LOGGER.LogWarning($"The LLM_PROVIDERS table at index {i} does not contain a valid provider configuration.");
+        }
+        
+        //
+        // Apply the configured providers to the system settings:
+        //
+        #pragma warning disable MWAIS0001
+        foreach (var configuredProvider in configuredProviders)
+        {
+            // The iterating variable is immutable, so we need to create a local copy:
+            var provider = configuredProvider;
+
+            var providerIndex = SETTINGS_MANAGER.ConfigurationData.Providers.FindIndex(p => p.Id == provider.Id);
+            if (providerIndex > -1)
+            {
+                // Case: The provider already exists, we update it:
+                var existingProvider = SETTINGS_MANAGER.ConfigurationData.Providers[providerIndex];
+                provider = provider with { Num = existingProvider.Num }; // Keep the original number
+                SETTINGS_MANAGER.ConfigurationData.Providers[providerIndex] = provider;
+            }
+            else
+            {
+                // Case: The provider does not exist, we add it:
+                provider = provider with { Num = SETTINGS_MANAGER.ConfigurationData.NextProviderNum++ };
+                SETTINGS_MANAGER.ConfigurationData.Providers.Add(provider);
+            }
+        }
+        #pragma warning restore MWAIS0001
+        
+        return true;
+    }
+    
+    private bool TryReadProviderTable(int idx, LuaTable table, out Settings.Provider provider)
+    {
+        provider = default;
+        if (!table.TryGetValue("Id", out var idValue) || !idValue.TryRead<string>(out var idText) || !Guid.TryParse(idText, out var id))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid ID. The ID must be a valid GUID.");
+            return false;
+        }
+
+        if (!table.TryGetValue("InstanceName", out var instanceNameValue) || !instanceNameValue.TryRead<string>(out var instanceName))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid instance name.");
+            return false;
+        }
+
+        if (!table.TryGetValue("UsedLLMProvider", out var usedLLMProviderValue) || !usedLLMProviderValue.TryRead<string>(out var usedLLMProviderText) || !Enum.TryParse<LLMProviders>(usedLLMProviderText, true, out var usedLLMProvider))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid LLM provider enum value.");
+            return false;
+        }
+        
+        if (!table.TryGetValue("Host", out var hostValue) || !hostValue.TryRead<string>(out var hostText) || !Enum.TryParse<Host>(hostText, true, out var host))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid host enum value.");
+            return false;
+        }
+        
+        if (!table.TryGetValue("Hostname", out var hostnameValue) || !hostnameValue.TryRead<string>(out var hostname))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid hostname.");
+            return false;
+        }
+        
+        if (!table.TryGetValue("Model", out var modelValue) || !modelValue.TryRead<LuaTable>(out var modelTable))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model table.");
+            return false;
+        }
+        
+        if (!this.TryReadModelTable(idx, modelTable, out var model))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model configuration.");
+            return false;
+        }
+
+        provider = new()
+        {
+            Num = 0,
+            Id = id.ToString(),
+            InstanceName = instanceName,
+            UsedLLMProvider = usedLLMProvider,
+            Model = model,
+            IsSelfHosted = usedLLMProvider is LLMProviders.SELF_HOSTED,
+            IsEnterpriseConfiguration = true,
+            EnterpriseConfigurationPluginId = this.Id,
+            Hostname = hostname,
+            Host = host
+        };
+        
+        return true;
+    }
+
+    private bool TryReadModelTable(int idx, LuaTable table, out Model model)
+    {
+        model = default;
+        if (!table.TryGetValue("Id", out var idValue) || !idValue.TryRead<string>(out var id))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model ID.");
+            return false;
+        }
+        
+        if (!table.TryGetValue("DisplayName", out var displayNameValue) || !displayNameValue.TryRead<string>(out var displayName))
+        {
+            LOGGER.LogWarning($"The configured provider {idx} does not contain a valid model display name.");
+            return false;
+        }
+        
+        model = new(id, displayName);
+        return true;
+    }
+}

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Download.cs

@@ -0,0 +1,56 @@
+using System.IO.Compression;
+
+namespace AIStudio.Tools.PluginSystem;
+
+public static partial class PluginFactory
+{
+    public static async Task<bool> TryDownloadingConfigPluginAsync(Guid configPlugId, string configServerUrl, CancellationToken cancellationToken = default)
+    {
+        if (!IS_INITIALIZED)
+            return false;
+
+        LOG.LogInformation($"Downloading configuration plugin with ID: {configPlugId} from server: {configServerUrl}");
+        var tempDownloadFile = Path.GetTempFileName();
+        try
+        {
+            using var httpClient = new HttpClient();
+            var response = await httpClient.GetAsync($"{configServerUrl}/{configPlugId}.zip", cancellationToken);
+            if (response.IsSuccessStatusCode)
+            {
+                await using var tempFileStream = File.Create(tempDownloadFile);
+                await response.Content.CopyToAsync(tempFileStream, cancellationToken);
+                
+                var pluginDirectory = Path.Join(CONFIGURATION_PLUGINS_ROOT, configPlugId.ToString());
+                if(Directory.Exists(pluginDirectory))
+                    Directory.Delete(pluginDirectory, true);
+                
+                Directory.CreateDirectory(pluginDirectory);
+                ZipFile.ExtractToDirectory(tempDownloadFile, pluginDirectory);
+                
+                LOG.LogInformation($"Configuration plugin with ID='{configPlugId}' downloaded and extracted successfully to '{pluginDirectory}'.");
+            }
+            else
+                LOG.LogError($"Failed to download the enterprise configuration plugin. HTTP Status: {response.StatusCode}");
+        }
+        catch (Exception e)
+        {
+            LOG.LogError(e, "An error occurred while downloading or extracting the enterprise configuration plugin.");
+        }
+        finally
+        {
+            if (File.Exists(tempDownloadFile))
+            {
+                try
+                {
+                    File.Delete(tempDownloadFile);
+                }
+                catch (Exception e)
+                {
+                    LOG.LogError(e, "Failed to delete the temporary download file.");
+                }
+            }
+        }
+        
+        return true;
+    }
+}

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.HotReload.cs

@@ -15,32 +15,11 @@ public static partial class PluginFactory
         LOG.LogInformation($"Start hot reloading plugins for path '{HOT_RELOAD_WATCHER.Path}'.");
         try
         {
-            var messageBus = Program.SERVICE_PROVIDER.GetRequiredService<MessageBus>();
-        
             HOT_RELOAD_WATCHER.IncludeSubdirectories = true;
             HOT_RELOAD_WATCHER.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName;
             HOT_RELOAD_WATCHER.Filter = "*.lua";
-            HOT_RELOAD_WATCHER.Changed += async (_, args) =>
-            {
-                var changeType = args.ChangeType.ToString().ToLowerInvariant();
-                if (!await HOT_RELOAD_SEMAPHORE.WaitAsync(0))
-                {
-                    LOG.LogInformation($"File changed ({changeType}): {args.FullPath}. Already processing another change.");
-                    return;
-                }
-
-                try
-                {
-                    LOG.LogInformation($"File changed ({changeType}): {args.FullPath}. Reloading plugins...");
-                    await LoadAll();
-                    await messageBus.SendMessage<bool>(null, Event.PLUGINS_RELOADED);
-                }
-                finally
-                {
-                    HOT_RELOAD_SEMAPHORE.Release();
-                }
-            };
-            
+            HOT_RELOAD_WATCHER.Changed += HotReloadEventHandler;
+            HOT_RELOAD_WATCHER.Deleted += HotReloadEventHandler;
             HOT_RELOAD_WATCHER.EnableRaisingEvents = true;
         }
         catch (Exception e)
@@ -52,4 +31,32 @@ public static partial class PluginFactory
             LOG.LogInformation("Hot reloading plugins set up.");
         }
     }
+    
+    private static async void HotReloadEventHandler(object _, FileSystemEventArgs args)
+    {
+        try
+        {
+            var changeType = args.ChangeType.ToString().ToLowerInvariant();
+            if (!await HOT_RELOAD_SEMAPHORE.WaitAsync(0))
+            {
+                LOG.LogInformation($"File changed ({changeType}): {args.FullPath}. Already processing another change.");
+                return;
+            }
+
+            try
+            {
+                LOG.LogInformation($"File changed ({changeType}): {args.FullPath}. Reloading plugins...");
+                await LoadAll();
+                await MessageBus.INSTANCE.SendMessage<bool>(null, Event.PLUGINS_RELOADED);
+            }
+            finally
+            {
+                HOT_RELOAD_SEMAPHORE.Release();
+            }
+        }
+        catch (Exception e)
+        {
+            LOG.LogError(e, $"Error while handling hot reload event for file '{args.FullPath}' with change type '{args.ChangeType}'.");
+        }
+    }
 }

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Loading.cs

@@ -1,5 +1,7 @@
 using System.Text;
 
+using AIStudio.Settings.DataModel;
+
 using Lua;
 using Lua.Standard;
 
@@ -58,8 +60,11 @@ public static partial class PluginFactory
                 try
                 {
                     if (cancellationToken.IsCancellationRequested)
+                    {
+                        LOG.LogWarning("Was not able to load all plugins, because the operation was cancelled. It seems to be a timeout.");
                         break;
-            
+                    }
+
                     LOG.LogInformation($"Try to load plugin: {pluginMainFile}");
                     var fileInfo = new FileInfo(pluginMainFile);
                     string code;
@@ -113,6 +118,61 @@ public static partial class PluginFactory
             PLUGIN_LOAD_SEMAPHORE.Release();
             LOG.LogInformation("Finished loading plugins.");
         }
+        
+        //
+        // Next, we have to clean up our settings. It is possible that a configuration plugin was removed.
+        // We have to remove the related settings as well:
+        //
+        var wasConfigurationChanged = false;
+        
+        //
+        // Check LLM providers:
+        //
+        #pragma warning disable MWAIS0001
+        var configuredProviders = SETTINGS_MANAGER.ConfigurationData.Providers.ToList();
+        foreach (var configuredProvider in configuredProviders)
+        {
+            if(!configuredProvider.IsEnterpriseConfiguration)
+                continue;
+
+            var providerSourcePluginId = configuredProvider.EnterpriseConfigurationPluginId;
+            if(providerSourcePluginId == Guid.Empty)
+                continue;
+            
+            var providerSourcePlugin = AVAILABLE_PLUGINS.FirstOrDefault(plugin => plugin.Id == providerSourcePluginId);
+            if(providerSourcePlugin is null)
+            {
+                LOG.LogWarning($"The configured LLM provider '{configuredProvider.InstanceName}' (id={configuredProvider.Id}) is based on a plugin that is not available anymore. Removing the provider from the settings.");
+                SETTINGS_MANAGER.ConfigurationData.Providers.Remove(configuredProvider);
+                wasConfigurationChanged = true;
+            }
+        }
+        #pragma warning restore MWAIS0001
+
+        //
+        // Check all possible settings:
+        //
+        if (SETTINGS_LOCKER.GetConfigurationPluginId<DataApp>(x => x.UpdateBehavior) is var updateBehaviorPluginId && updateBehaviorPluginId != Guid.Empty)
+        {
+            var sourcePlugin = AVAILABLE_PLUGINS.FirstOrDefault(plugin => plugin.Id == updateBehaviorPluginId);
+            if (sourcePlugin is null)
+            {
+                // Remove the locked state:
+                SETTINGS_LOCKER.Remove<DataApp>(x => x.UpdateBehavior);
+                
+                // Reset the setting to the default value:
+                SETTINGS_MANAGER.ConfigurationData.App.UpdateBehavior = UpdateBehavior.HOURLY;
+                
+                LOG.LogWarning($"The configured update behavior is based on a plugin that is not available anymore. Resetting the setting to the default value: {SETTINGS_MANAGER.ConfigurationData.App.UpdateBehavior}.");
+                wasConfigurationChanged = true;
+            }
+        }
+        
+        if (wasConfigurationChanged)
+        {
+            await SETTINGS_MANAGER.StoreSettings();
+            await MessageBus.INSTANCE.SendMessage<bool>(null, Event.CONFIGURATION_CHANGED);
+        }
     }
 
     public static async Task<PluginBase> Load(string? pluginPath, string code, CancellationToken cancellationToken = default)
@@ -158,11 +218,18 @@ public static partial class PluginFactory
             return new NoPlugin($"TYPE is not a valid plugin type. Valid types are: {CommonTools.GetAllEnumValues<PluginType>()}");
         
         var isInternal = !string.IsNullOrWhiteSpace(pluginPath) && pluginPath.StartsWith(INTERNAL_PLUGINS_ROOT, StringComparison.OrdinalIgnoreCase);
-        return type switch
+        switch (type)
         {
-            PluginType.LANGUAGE => new PluginLanguage(isInternal, state, type),
+            case PluginType.LANGUAGE:
+                return new PluginLanguage(isInternal, state, type);
             
-            _ => new NoPlugin("This plugin type is not supported yet. Please try again with a future version of AI Studio.")
-        };
+            case PluginType.CONFIGURATION:
+                var configPlug = new PluginConfiguration(isInternal, state, type);
+                await configPlug.InitializeAsync();
+                return configPlug;
+            
+            default:
+                return new NoPlugin("This plugin type is not supported yet. Please try again with a future version of AI Studio.");
+        }
     }
 }

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Remove.cs

@@ -0,0 +1,54 @@
+namespace AIStudio.Tools.PluginSystem;
+
+public static partial class PluginFactory
+{
+    public static void RemovePluginAsync(Guid pluginId)
+    {
+        if (!IS_INITIALIZED)
+            return;
+
+        LOG.LogWarning($"Try to remove plugin with ID: {pluginId}");
+
+        //
+        // Remove the plugin from the available plugins list:
+        //
+        var availablePluginToRemove = AVAILABLE_PLUGINS.FirstOrDefault(p => p.Id == pluginId);
+        if (availablePluginToRemove == null)
+        {
+            LOG.LogWarning($"No plugin found with ID: {pluginId}");
+            return;
+        }
+
+        AVAILABLE_PLUGINS.Remove(availablePluginToRemove);
+        
+        //
+        // Remove the plugin from the running plugins list:
+        //
+        var runningPluginToRemove = RUNNING_PLUGINS.FirstOrDefault(p => p.Id == pluginId);
+        if (runningPluginToRemove == null)
+            LOG.LogWarning($"No running plugin found with ID: {pluginId}");
+        else
+            RUNNING_PLUGINS.Remove(runningPluginToRemove);
+
+        //
+        // Delete the plugin directory:
+        //
+        var pluginDirectory = Path.Join(CONFIGURATION_PLUGINS_ROOT, availablePluginToRemove.Id.ToString());
+        if (Directory.Exists(pluginDirectory))
+        {
+            try
+            {
+                Directory.Delete(pluginDirectory, true);
+                LOG.LogInformation($"Plugin directory '{pluginDirectory}' deleted successfully.");
+            }
+            catch (Exception ex)
+            {
+                LOG.LogError(ex, $"Failed to delete plugin directory '{pluginDirectory}'.");
+            }
+        }
+        else
+            LOG.LogWarning($"Plugin directory '{pluginDirectory}' does not exist.");
+
+        LOG.LogInformation($"Plugin with ID: {pluginId} removed successfully.");
+    }
+}

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Starting.cs

@@ -22,48 +22,59 @@ public static partial class PluginFactory
         var baseLanguagePluginId = InternalPlugin.LANGUAGE_EN_US.MetaData().Id;
         var baseLanguagePluginMetaData = AVAILABLE_PLUGINS.FirstOrDefault(p => p.Id == baseLanguagePluginId);
         if (baseLanguagePluginMetaData is null)
-        {
             LOG.LogError($"Was not able to find the base language plugin: Id='{baseLanguagePluginId}'. Please check your installation.");
-            return;
-        }
-
-        var startedBasePlugin = await Start(baseLanguagePluginMetaData, cancellationToken);
-        if (startedBasePlugin is NoPlugin noPlugin)
-        {
-            LOG.LogError($"Was not able to start the base language plugin: Id='{baseLanguagePluginId}'. Reason: {noPlugin.Issues.First()}");
-            return;
-        }
-        
-        if (startedBasePlugin is PluginLanguage languagePlugin)
-        {
-            BASE_LANGUAGE_PLUGIN = languagePlugin;
-            RUNNING_PLUGINS.Add(languagePlugin);
-            LOG.LogInformation($"Successfully started the base language plugin: Id='{languagePlugin.Id}', Type='{languagePlugin.Type}', Name='{languagePlugin.Name}', Version='{languagePlugin.Version}'");
-        }
         else
         {
-            LOG.LogError($"Was not able to start the base language plugin: Id='{baseLanguagePluginId}'. Reason: {string.Join("; ", startedBasePlugin.Issues)}");
-            return;
+            try
+            {
+                var startedBasePlugin = await Start(baseLanguagePluginMetaData, cancellationToken);
+                if (startedBasePlugin is NoPlugin noPlugin)
+                    LOG.LogError($"Was not able to start the base language plugin: Id='{baseLanguagePluginId}'. Reason: {noPlugin.Issues.First()}");
+        
+                if (startedBasePlugin is PluginLanguage languagePlugin)
+                {
+                    BASE_LANGUAGE_PLUGIN = languagePlugin;
+                    RUNNING_PLUGINS.Add(languagePlugin);
+                    LOG.LogInformation($"Successfully started the base language plugin: Id='{languagePlugin.Id}', Type='{languagePlugin.Type}', Name='{languagePlugin.Name}', Version='{languagePlugin.Version}'");
+                }
+                else
+                    LOG.LogError($"Was not able to start the base language plugin: Id='{baseLanguagePluginId}'. Reason: {string.Join("; ", startedBasePlugin.Issues)}");
+            }
+            catch (Exception e)
+            {
+                LOG.LogError(e, $"An error occurred while starting the base language plugin: Id='{baseLanguagePluginId}'.");
+                BASE_LANGUAGE_PLUGIN = NoPluginLanguage.INSTANCE;
+            }
         }
-
+        
         //
         // Iterate over all available plugins and try to start them.
         //
         foreach (var availablePlugin in AVAILABLE_PLUGINS)
         {
             if(cancellationToken.IsCancellationRequested)
+            {
+                LOG.LogWarning("Cancellation requested while starting plugins. Stopping the plugin startup process. Probably due to a timeout.");
                 break;
-            
+            }
+
             if (availablePlugin.Id == baseLanguagePluginId)
                 continue;
-            
-            if (availablePlugin.IsInternal || SETTINGS_MANAGER.IsPluginEnabled(availablePlugin))
-                if(await Start(availablePlugin, cancellationToken) is { IsValid: true } plugin)
-                    RUNNING_PLUGINS.Add(plugin);
 
-            // Inform all components that the plugins have been reloaded or started:
-            await MessageBus.INSTANCE.SendMessage<bool>(null, Event.PLUGINS_RELOADED);
+            try
+            {
+                if (availablePlugin.IsInternal || SETTINGS_MANAGER.IsPluginEnabled(availablePlugin) || availablePlugin.Type == PluginType.CONFIGURATION)
+                    if(await Start(availablePlugin, cancellationToken) is { IsValid: true } plugin)
+                        RUNNING_PLUGINS.Add(plugin);
+            }
+            catch (Exception e)
+            {
+                LOG.LogError(e, $"An error occurred while starting the plugin: Id='{availablePlugin.Id}', Type='{availablePlugin.Type}', Name='{availablePlugin.Name}', Version='{availablePlugin.Version}'.");
+            }
         }
+        
+        // Inform all components that the plugins have been reloaded or started:
+        await MessageBus.INSTANCE.SendMessage<bool>(null, Event.PLUGINS_RELOADED);
     }
     
     private static async Task<PluginBase> Start(IAvailablePlugin meta, CancellationToken cancellationToken = default)
@@ -91,6 +102,9 @@ public static partial class PluginFactory
             if (plugin is PluginLanguage languagePlugin && BASE_LANGUAGE_PLUGIN != NoPluginLanguage.INSTANCE)
                 languagePlugin.SetBaseLanguage(BASE_LANGUAGE_PLUGIN);
             
+            if(plugin is PluginConfiguration configPlugin)
+                await configPlugin.InitializeAsync();
+            
             LOG.LogInformation($"Successfully started plugin: Id='{plugin.Id}', Type='{plugin.Type}', Name='{plugin.Name}', Version='{plugin.Version}'");
             return plugin;
         }

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.cs

@@ -6,11 +6,13 @@ public static partial class PluginFactory
 {
     private static readonly ILogger LOG = Program.LOGGER_FACTORY.CreateLogger(nameof(PluginFactory));
     private static readonly SettingsManager SETTINGS_MANAGER = Program.SERVICE_PROVIDER.GetRequiredService<SettingsManager>();
+    private static readonly SettingsLocker SETTINGS_LOCKER = Program.SERVICE_PROVIDER.GetRequiredService<SettingsLocker>();
     
     private static bool IS_INITIALIZED;
     private static string DATA_DIR = string.Empty;
     private static string PLUGINS_ROOT = string.Empty;
     private static string INTERNAL_PLUGINS_ROOT = string.Empty;
+    private static string CONFIGURATION_PLUGINS_ROOT = string.Empty;
     private static FileSystemWatcher HOT_RELOAD_WATCHER = null!;
     private static ILanguagePlugin BASE_LANGUAGE_PLUGIN = NoPluginLanguage.INSTANCE;
 
@@ -28,6 +30,7 @@ public static partial class PluginFactory
         DATA_DIR = SettingsManager.DataDirectory!;
         PLUGINS_ROOT = Path.Join(DATA_DIR, "plugins");
         INTERNAL_PLUGINS_ROOT = Path.Join(PLUGINS_ROOT, ".internal");
+        CONFIGURATION_PLUGINS_ROOT = Path.Join(PLUGINS_ROOT, ".config");
         
         if (!Directory.Exists(PLUGINS_ROOT))
             Directory.CreateDirectory(PLUGINS_ROOT);