Merge pull request #329 from keboola/upstream/slack-provider

Add Slack platform integration with database-backed configuration

Author: 239573049

src/OpenDeepWiki/Chat/ChatServiceExtensions.cs

@@ -183,7 +183,10 @@ private static IServiceCollection AddChatBackgroundServices(this IServiceCollect
         {
             services.AddHostedService<ConfigReloadService>();
         }
-        
+
+        // Apply DB config to providers after they are initialized
+        services.AddHostedService<ProviderConfigApplicator>();
+
         return services;
     }
 

src/OpenDeepWiki/Chat/Config/ChatConfigService.cs

@@ -13,25 +13,29 @@ public class ChatConfigService : IChatConfigService
 {
     private readonly IContext _context;
     private readonly IConfigEncryption _encryption;
+    private readonly IConfigChangeNotifier _changeNotifier;
     private readonly ILogger<ChatConfigService> _logger;
     private readonly List<Action<string>> _changeCallbacks = new();
     private readonly object _callbackLock = new();
-    
+
     // 必需的配置字段（按平台）
     private static readonly Dictionary<string, string[]> RequiredFields = new()
     {
         ["feishu"] = new[] { "AppId", "AppSecret" },
         ["qq"] = new[] { "AppId", "Token" },
-        ["wechat"] = new[] { "AppId", "AppSecret", "Token", "EncodingAesKey" }
+        ["wechat"] = new[] { "AppId", "AppSecret", "Token", "EncodingAesKey" },
+        ["slack"] = new[] { "BotToken", "SigningSecret" }
     };
 
     public ChatConfigService(
         IContext context,
         IConfigEncryption encryption,
+        IConfigChangeNotifier changeNotifier,
         ILogger<ChatConfigService> logger)
     {
         _context = context;
         _encryption = encryption;
+        _changeNotifier = changeNotifier;
         _logger = logger;
     }
 
@@ -113,9 +117,9 @@ public async Task DeleteConfigAsync(string platform, CancellationToken cancellat
             _context.ChatProviderConfigs.Remove(entity);
             await _context.SaveChangesAsync(cancellationToken);
             _logger.LogInformation("Deleted config for platform: {Platform}", platform);
-            
+
             // 触发变更通知
-            NotifyConfigChanged(platform);
+            NotifyConfigChanged(platform, ConfigChangeType.Deleted);
         }
     }
 
@@ -263,14 +267,15 @@ private static string[] GetRequiredFieldsForPlatform(string platform)
     /// <summary>
     /// 通知配置变更
     /// </summary>
-    private void NotifyConfigChanged(string platform)
+    private void NotifyConfigChanged(string platform, ConfigChangeType changeType = ConfigChangeType.Updated)
     {
+        // Fire local scoped callbacks (existing behavior)
         List<Action<string>> callbacks;
         lock (_callbackLock)
         {
             callbacks = _changeCallbacks.ToList();
         }
-        
+
         foreach (var callback in callbacks)
         {
             try
@@ -282,6 +287,16 @@ private void NotifyConfigChanged(string platform)
                 _logger.LogError(ex, "Error in config change callback for platform: {Platform}", platform);
             }
         }
+
+        // Fire global singleton notifier so ProviderConfigApplicator picks up changes immediately
+        try
+        {
+            _changeNotifier.NotifyChange(platform, changeType);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error firing global config change notification for platform: {Platform}", platform);
+        }
     }
 
     /// <summary>

src/OpenDeepWiki/Chat/Config/ProviderConfigApplicator.cs

@@ -0,0 +1,142 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using OpenDeepWiki.Chat.Providers;
+using OpenDeepWiki.Chat.Routing;
+
+namespace OpenDeepWiki.Chat.Config;
+
+/// <summary>
+/// Bridges database configuration to live provider instances.
+/// On startup, loads DB config for all registered IConfigurableProvider providers.
+/// At runtime, subscribes to IConfigChangeNotifier to apply config changes immediately.
+/// </summary>
+public class ProviderConfigApplicator : IHostedService, IDisposable
+{
+    private readonly IMessageRouter _router;
+    private readonly IConfigChangeNotifier _changeNotifier;
+    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly ILogger<ProviderConfigApplicator> _logger;
+    private IDisposable? _subscription;
+
+    public ProviderConfigApplicator(
+        IMessageRouter router,
+        IConfigChangeNotifier changeNotifier,
+        IServiceScopeFactory scopeFactory,
+        ILogger<ProviderConfigApplicator> logger)
+    {
+        _router = router;
+        _changeNotifier = changeNotifier;
+        _scopeFactory = scopeFactory;
+        _logger = logger;
+    }
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("ProviderConfigApplicator starting: applying DB configs to registered providers");
+
+        await ApplyAllDbConfigsAsync(cancellationToken);
+
+        // Subscribe to all platform changes for runtime hot-reload
+        _subscription = _changeNotifier.Subscribe(null, OnConfigChanged);
+
+        _logger.LogInformation("ProviderConfigApplicator started: subscribed to config change notifications");
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        _subscription?.Dispose();
+        _subscription = null;
+        _logger.LogInformation("ProviderConfigApplicator stopped");
+        return Task.CompletedTask;
+    }
+
+    public void Dispose()
+    {
+        _subscription?.Dispose();
+    }
+
+    private async Task ApplyAllDbConfigsAsync(CancellationToken cancellationToken)
+    {
+        using var scope = _scopeFactory.CreateScope();
+        var configService = scope.ServiceProvider.GetRequiredService<IChatConfigService>();
+
+        foreach (var provider in _router.GetAllProviders())
+        {
+            if (provider is not IConfigurableProvider configurable)
+                continue;
+
+            try
+            {
+                var dbConfig = await configService.GetConfigAsync(provider.PlatformId, cancellationToken);
+                if (dbConfig != null)
+                {
+                    configurable.ApplyConfig(dbConfig);
+                    _logger.LogInformation(
+                        "Applied DB config to provider {Platform} at startup", provider.PlatformId);
+                }
+                else
+                {
+                    _logger.LogDebug(
+                        "No DB config for provider {Platform}, using environment variable defaults",
+                        provider.PlatformId);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex,
+                    "Failed to apply DB config to provider {Platform} at startup, falling back to env vars",
+                    provider.PlatformId);
+            }
+        }
+    }
+
+    private void OnConfigChanged(ConfigChangeEvent evt)
+    {
+        // Fire-and-forget with error handling (notification callback is synchronous)
+        _ = Task.Run(async () =>
+        {
+            try
+            {
+                await ApplyConfigForPlatformAsync(evt.Platform, evt.ChangeType);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to apply config change for platform {Platform}", evt.Platform);
+            }
+        });
+    }
+
+    private async Task ApplyConfigForPlatformAsync(string platform, ConfigChangeType changeType)
+    {
+        var provider = _router.GetProvider(platform);
+        if (provider is not IConfigurableProvider configurable)
+        {
+            _logger.LogDebug("Provider {Platform} does not support runtime config updates", platform);
+            return;
+        }
+
+        if (changeType == ConfigChangeType.Deleted)
+        {
+            configurable.ResetToDefaults();
+            _logger.LogInformation("Reset provider {Platform} to env var defaults (DB config deleted)", platform);
+            return;
+        }
+
+        using var scope = _scopeFactory.CreateScope();
+        var configService = scope.ServiceProvider.GetRequiredService<IChatConfigService>();
+        var dbConfig = await configService.GetConfigAsync(platform);
+
+        if (dbConfig != null)
+        {
+            configurable.ApplyConfig(dbConfig);
+            _logger.LogInformation("Applied updated DB config to provider {Platform} (change: {ChangeType})",
+                platform, changeType);
+        }
+        else
+        {
+            configurable.ResetToDefaults();
+            _logger.LogInformation("Reset provider {Platform} to env var defaults (DB config not found)", platform);
+        }
+    }
+}

src/OpenDeepWiki/Chat/Execution/ChatUserResolver.cs

@@ -3,8 +3,8 @@
 using System.Text.Json;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using OpenDeepWiki.Chat.Providers.Slack;
+using OpenDeepWiki.Chat.Routing;
 using OpenDeepWiki.EFCore;
 
 namespace OpenDeepWiki.Chat.Execution;
@@ -24,11 +24,13 @@ public interface IChatUserResolver
 /// <summary>
 /// Resolves Slack (and other platform) user IDs to DeepWiki user IDs by email matching.
 /// Singleton service with in-memory caching.
+/// Reads Slack config from the live SlackProvider (via IMessageRouter) so that
+/// database-backed config changes are picked up automatically.
 /// </summary>
 public class ChatUserResolver : IChatUserResolver
 {
     private readonly IContextFactory _contextFactory;
-    private readonly SlackProviderOptions _slackOptions;
+    private readonly IMessageRouter _messageRouter;
     private readonly HttpClient _httpClient;
     private readonly ILogger<ChatUserResolver> _logger;
 
@@ -38,12 +40,12 @@ public class ChatUserResolver : IChatUserResolver
 
     public ChatUserResolver(
         IContextFactory contextFactory,
-        IOptions<SlackProviderOptions> slackOptions,
+        IMessageRouter messageRouter,
         HttpClient httpClient,
         ILogger<ChatUserResolver> logger)
     {
         _contextFactory = contextFactory;
-        _slackOptions = slackOptions.Value;
+        _messageRouter = messageRouter;
         _httpClient = httpClient;
         _logger = logger;
     }
@@ -114,18 +116,30 @@ public ChatUserResolver(
     /// <summary>
     /// Calls Slack users.info API to get the user's email address.
     /// Requires users:read.email OAuth scope on the Slack App.
+    /// Reads BotToken from the live SlackProvider registered in the router,
+    /// which reflects database-backed config updates.
     /// </summary>
     private async Task<string?> GetSlackUserEmailAsync(string slackUserId, CancellationToken cancellationToken)
     {
-        if (string.IsNullOrEmpty(_slackOptions.BotToken))
+        var slackProvider = _messageRouter.GetProvider("slack") as SlackProvider;
+        if (slackProvider == null)
+        {
+            _logger.LogWarning("Slack provider not registered, cannot resolve user email");
+            return null;
+        }
+
+        var botToken = slackProvider.ActiveBotToken;
+        var apiBaseUrl = slackProvider.ActiveApiBaseUrl;
+
+        if (string.IsNullOrEmpty(botToken))
         {
             _logger.LogWarning("Slack BotToken not configured, cannot resolve user email");
             return null;
         }
 
-        var url = $"{_slackOptions.ApiBaseUrl}/users.info?user={slackUserId}";
+        var url = $"{apiBaseUrl}/users.info?user={slackUserId}";
         var request = new HttpRequestMessage(HttpMethod.Get, url);
-        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _slackOptions.BotToken);
+        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", botToken);
 
         var response = await _httpClient.SendAsync(request, cancellationToken);
         var content = await response.Content.ReadAsStringAsync(cancellationToken);

src/OpenDeepWiki/Chat/Providers/IConfigurableProvider.cs

@@ -0,0 +1,27 @@
+using OpenDeepWiki.Chat.Config;
+
+namespace OpenDeepWiki.Chat.Providers;
+
+/// <summary>
+/// Interface for providers that support runtime configuration updates from database.
+/// Providers implementing this interface can have their config applied/reverted
+/// by the ProviderConfigApplicator hosted service.
+/// </summary>
+public interface IConfigurableProvider
+{
+    /// <summary>
+    /// Apply configuration from database DTO.
+    /// Thread-safe: implementations must ensure concurrent requests see a consistent state.
+    /// </summary>
+    void ApplyConfig(ProviderConfigDto config);
+
+    /// <summary>
+    /// Reset to environment-variable-based configuration (when DB config is deleted).
+    /// </summary>
+    void ResetToDefaults();
+
+    /// <summary>
+    /// Where the current config came from: "database" or "environment".
+    /// </summary>
+    string ConfigSource { get; }
+}