Manage global shortcuts (#635)

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

@@ -70,6 +70,9 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
         // Config: hide some assistants?
         ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.HiddenAssistants, this.Id, settingsTable, dryRun);
         
+        // Config: global voice recording shortcut
+        ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.ShortcutVoiceRecording, this.Id, settingsTable, dryRun);
+        
         // Handle configured LLM providers:
         PluginConfigurationObject.TryParse(PluginConfigurationObjectType.LLM_PROVIDER, x => x.Providers, x => x.NextProviderNum, mainTable, this.Id, ref this.configObjects, dryRun);
 

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

@@ -181,6 +181,10 @@ public static partial class PluginFactory
         if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.HiddenAssistants, AVAILABLE_PLUGINS))
             wasConfigurationChanged = true;
         
+        // Check for the voice recording shortcut:
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.ShortcutVoiceRecording, AVAILABLE_PLUGINS))
+            wasConfigurationChanged = true;
+        
         if (wasConfigurationChanged)
         {
             await SETTINGS_MANAGER.StoreSettings();

app/MindWork AI Studio/Tools/Rust/RegisterShortcutRequest.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Tools.Rust;
+
+public sealed record RegisterShortcutRequest(Shortcut Id, string Shortcut);

app/MindWork AI Studio/Tools/Rust/Shortcut.cs

@@ -0,0 +1,17 @@
+namespace AIStudio.Tools.Rust;
+
+/// <summary>
+/// Identifies a global keyboard shortcut.
+/// </summary>
+public enum Shortcut
+{
+    /// <summary>
+    /// Null pattern - no shortcut assigned or unknown shortcut.
+    /// </summary>
+    NONE = 0,
+    
+    /// <summary>
+    /// Toggles voice recording on/off.
+    /// </summary>
+    VOICE_RECORDING_TOGGLE,
+}

app/MindWork AI Studio/Tools/Rust/ShortcutResponse.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Tools.Rust;
+
+public sealed record ShortcutResponse(bool Success, string ErrorMessage);

app/MindWork AI Studio/Tools/Rust/ShortcutValidationResponse.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Tools.Rust;
+
+public sealed record ShortcutValidationResponse(bool IsValid, string ErrorMessage, bool HasConflict, string ConflictDescription);

app/MindWork AI Studio/Tools/Rust/ShortcutValidationResult.cs

@@ -0,0 +1,10 @@
+namespace AIStudio.Tools.Rust;
+
+/// <summary>
+/// Result of validating a keyboard shortcut.
+/// </summary>
+/// <param name="IsValid">Whether the shortcut syntax is valid.</param>
+/// <param name="ErrorMessage">Error message if not valid.</param>
+/// <param name="HasConflict">Whether the shortcut conflicts with another registered shortcut.</param>
+/// <param name="ConflictDescription">Description of the conflict, if any.</param>
+public sealed record ShortcutValidationResult(bool IsValid, string ErrorMessage, bool HasConflict, string ConflictDescription);

app/MindWork AI Studio/Tools/Rust/TauriEvent.cs

@@ -5,4 +5,41 @@ namespace AIStudio.Tools.Rust;
 /// </summary>
 /// <param name="EventType">The type of the Tauri event.</param>
 /// <param name="Payload">The payload of the Tauri event.</param>
-public readonly record struct TauriEvent(TauriEventType EventType, List<string> Payload);
+public readonly record struct TauriEvent(TauriEventType EventType, List<string> Payload)
+{
+    /// <summary>
+    /// Attempts to parse the first payload element as a shortcut.
+    /// </summary>
+    /// <param name="shortcut">The parsed shortcut name if successful.</param>
+    /// <returns>True if parsing was successful, false otherwise.</returns>
+    public bool TryGetShortcut(out Shortcut shortcut)
+    {
+        shortcut = default;
+        if(this.EventType != TauriEventType.GLOBAL_SHORTCUT_PRESSED)
+            return false;
+        
+        if (this.Payload.Count == 0)
+            return false;
+
+        // Try standard enum parsing (handles PascalCase and numeric values):
+        if (Enum.TryParse(this.Payload[0], ignoreCase: true, out shortcut))
+            return true;
+
+        // Try parsing snake_case format (e.g., "voice_recording_toggle"):
+        return TryParseSnakeCase(this.Payload[0], out shortcut);
+    }
+
+    /// <summary>
+    /// Tries to parse a snake_case string into a ShortcutName enum value.
+    /// </summary>
+    private static bool TryParseSnakeCase(string value, out Shortcut shortcut)
+    {
+        shortcut = default;
+
+        // Convert snake_case to UPPER_SNAKE_CASE for enum matching:
+        var upperSnakeCase = value.ToUpperInvariant();
+
+        // Try to match against enum names (which are in UPPER_SNAKE_CASE):
+        return Enum.TryParse(upperSnakeCase, ignoreCase: false, out shortcut);
+    }
+};

app/MindWork AI Studio/Tools/Rust/TauriEventType.cs

@@ -8,11 +8,13 @@ public enum TauriEventType
     NONE,
     PING,
     UNKNOWN,
-    
+
     WINDOW_FOCUSED,
     WINDOW_NOT_FOCUSED,
-    
+
     FILE_DROP_HOVERED,
     FILE_DROP_DROPPED,
     FILE_DROP_CANCELED,
+
+    GLOBAL_SHORTCUT_PRESSED,
 }

app/MindWork AI Studio/Tools/Rust/ValidateShortcutRequest.cs

@@ -0,0 +1,3 @@
+namespace AIStudio.Tools.Rust;
+
+public sealed record ValidateShortcutRequest(string Shortcut);

app/MindWork AI Studio/Tools/Services/GlobalShortcutService.cs

@@ -0,0 +1,111 @@
+using AIStudio.Settings;
+using AIStudio.Settings.DataModel;
+using AIStudio.Tools.Rust;
+
+using Microsoft.AspNetCore.Components;
+
+namespace AIStudio.Tools.Services;
+
+public sealed class GlobalShortcutService : BackgroundService, IMessageBusReceiver
+{
+    private static bool IS_INITIALIZED;
+
+    private readonly ILogger<GlobalShortcutService> logger;
+    private readonly SettingsManager settingsManager;
+    private readonly MessageBus messageBus;
+    private readonly RustService rustService;
+
+    public GlobalShortcutService(
+        ILogger<GlobalShortcutService> logger,
+        SettingsManager settingsManager,
+        MessageBus messageBus,
+        RustService rustService)
+    {
+        this.logger = logger;
+        this.settingsManager = settingsManager;
+        this.messageBus = messageBus;
+        this.rustService = rustService;
+
+        this.messageBus.RegisterComponent(this);
+        this.ApplyFilters([], [Event.CONFIGURATION_CHANGED]);
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        // Wait until the app is fully initialized:
+        while (!stoppingToken.IsCancellationRequested && !IS_INITIALIZED)
+            await Task.Delay(TimeSpan.FromSeconds(1), stoppingToken);
+
+        // Register shortcuts on startup:
+        await this.RegisterAllShortcuts();
+    }
+
+    public override async Task StopAsync(CancellationToken cancellationToken)
+    {
+        this.messageBus.Unregister(this);
+        await base.StopAsync(cancellationToken);
+    }
+
+    #region IMessageBusReceiver
+    
+    public async Task ProcessMessage<T>(ComponentBase? sendingComponent, Event triggeredEvent, T? data)
+    {
+        switch (triggeredEvent)
+        {
+            case Event.CONFIGURATION_CHANGED:
+                await this.RegisterAllShortcuts();
+                break;
+        }
+    }
+
+    public Task<TResult?> ProcessMessageWithResult<TPayload, TResult>(ComponentBase? sendingComponent, Event triggeredEvent, TPayload? data) => Task.FromResult<TResult?>(default);
+
+    #endregion
+
+    private async Task RegisterAllShortcuts()
+    {
+        this.logger.LogInformation("Registering global shortcuts.");
+        foreach (var shortcutId in Enum.GetValues<Shortcut>())
+        {
+            if(shortcutId is Shortcut.NONE)
+                continue;
+            
+            var shortcut = this.GetShortcutValue(shortcutId);
+            var isEnabled = this.IsShortcutAllowed(shortcutId);
+
+            if (isEnabled && !string.IsNullOrWhiteSpace(shortcut))
+            {
+                var success = await this.rustService.UpdateGlobalShortcut(shortcutId, shortcut);
+                if (success)
+                    this.logger.LogInformation("Global shortcut '{ShortcutId}' ({Shortcut}) registered.", shortcutId, shortcut);
+                else
+                    this.logger.LogWarning("Failed to register global shortcut '{ShortcutId}' ({Shortcut}).", shortcutId, shortcut);
+            }
+            else
+            {
+                // Disable the shortcut when empty or feature is disabled:
+                await this.rustService.UpdateGlobalShortcut(shortcutId, string.Empty);
+            }
+        }
+
+        this.logger.LogInformation("Global shortcuts registration completed.");
+    }
+
+    private string GetShortcutValue(Shortcut name) => name switch
+    {
+        Shortcut.VOICE_RECORDING_TOGGLE => this.settingsManager.ConfigurationData.App.ShortcutVoiceRecording,
+        
+        _ => string.Empty,
+    };
+
+    private bool IsShortcutAllowed(Shortcut name) => name switch
+    {
+        // Voice recording is a preview feature:
+        Shortcut.VOICE_RECORDING_TOGGLE => PreviewFeatures.PRE_SPEECH_TO_TEXT_2026.IsEnabled(this.settingsManager),
+        
+        // Other shortcuts are always allowed:
+        _ => true,
+    };
+
+    public static void Initialize() => IS_INITIALIZED = true;
+}

app/MindWork AI Studio/Tools/Services/RustEnumConverter.cs

@@ -0,0 +1,112 @@
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace AIStudio.Tools.Services;
+
+/// <summary>
+/// Converts enum values for Rust communication.
+/// </summary>
+/// <remarks>
+/// Rust expects PascalCase enum values (e.g., "VoiceRecordingToggle"),
+/// while .NET uses UPPER_SNAKE_CASE (e.g., "VOICE_RECORDING_TOGGLE").
+/// This converter handles the bidirectional conversion.
+/// </remarks>
+public sealed class RustEnumConverter : JsonConverter<object>
+{
+    private static readonly ILogger<RustEnumConverter> LOG = Program.LOGGER_FACTORY.CreateLogger<RustEnumConverter>();
+
+    public override bool CanConvert(Type typeToConvert) => typeToConvert.IsEnum;
+
+    public override object? Read(ref Utf8JsonReader reader, Type enumType, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var text = reader.GetString();
+            text = ConvertToUpperSnakeCase(text);
+
+            if (Enum.TryParse(enumType, text, out var result))
+                return result;
+        }
+
+        LOG.LogWarning($"Cannot read '{reader.GetString()}' as '{enumType.Name}' enum; token type: {reader.TokenType}");
+        return Activator.CreateInstance(enumType);
+    }
+
+    public override object ReadAsPropertyName(ref Utf8JsonReader reader, Type enumType, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.PropertyName)
+        {
+            var text = reader.GetString();
+            text = ConvertToUpperSnakeCase(text);
+
+            if (Enum.TryParse(enumType, text, out var result))
+                return result;
+        }
+
+        LOG.LogWarning($"Cannot read '{reader.GetString()}' as '{enumType.Name}' enum; token type: {reader.TokenType}");
+        return Activator.CreateInstance(enumType)!;
+    }
+
+    public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(ConvertToPascalCase(value.ToString()));
+    }
+
+    public override void WriteAsPropertyName(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
+    {
+        writer.WritePropertyName(ConvertToPascalCase(value.ToString()));
+    }
+
+    /// <summary>
+    /// Converts UPPER_SNAKE_CASE to PascalCase.
+    /// </summary>
+    /// <param name="text">The text to convert (e.g., "VOICE_RECORDING_TOGGLE").</param>
+    /// <returns>The converted text as PascalCase (e.g., "VoiceRecordingToggle").</returns>
+    private static string ConvertToPascalCase(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+            return string.Empty;
+
+        var parts = text.Split('_', StringSplitOptions.RemoveEmptyEntries);
+        var sb = new StringBuilder();
+
+        foreach (var part in parts)
+        {
+            if (part.Length == 0)
+                continue;
+
+            // First character uppercase, rest lowercase:
+            sb.Append(char.ToUpperInvariant(part[0]));
+            if (part.Length > 1)
+                sb.Append(part[1..].ToLowerInvariant());
+        }
+
+        return sb.ToString();
+    }
+
+    /// <summary>
+    /// Converts a string to UPPER_SNAKE_CASE.
+    /// </summary>
+    /// <param name="text">The text to convert.</param>
+    /// <returns>The converted text as UPPER_SNAKE_CASE.</returns>
+    private static string ConvertToUpperSnakeCase(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+            return string.Empty;
+
+        var sb = new StringBuilder(text.Length);
+        var lastCharWasLowerCase = false;
+
+        foreach (var c in text)
+        {
+            if (char.IsUpper(c) && lastCharWasLowerCase)
+                sb.Append('_');
+
+            sb.Append(char.ToUpperInvariant(c));
+            lastCharWasLowerCase = char.IsLower(c);
+        }
+
+        return sb.ToString();
+    }
+}

app/MindWork AI Studio/Tools/Services/RustService.Shortcuts.cs

@@ -0,0 +1,140 @@
+// ReSharper disable NotAccessedPositionalProperty.Local
+using AIStudio.Tools.Rust;
+
+namespace AIStudio.Tools.Services;
+
+public sealed partial class RustService
+{
+    /// <summary>
+    /// Registers or updates a global keyboard shortcut.
+    /// </summary>
+    /// <param name="shortcutId">The identifier for the shortcut.</param>
+    /// <param name="shortcut">The shortcut string in Tauri format (e.g., "CmdOrControl+1"). Use empty string to disable.</param>
+    /// <returns>True if the shortcut was registered successfully, false otherwise.</returns>
+    public async Task<bool> UpdateGlobalShortcut(Shortcut shortcutId, string shortcut)
+    {
+        try
+        {
+            var request = new RegisterShortcutRequest(shortcutId, shortcut);
+            var response = await this.http.PostAsJsonAsync("/shortcuts/register", request, this.jsonRustSerializerOptions);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                this.logger?.LogError("Failed to register global shortcut '{ShortcutId}' due to network error: {StatusCode}", shortcutId, response.StatusCode);
+                return false;
+            }
+
+            var result = await response.Content.ReadFromJsonAsync<ShortcutResponse>(this.jsonRustSerializerOptions);
+            if (result is null || !result.Success)
+            {
+                this.logger?.LogError("Failed to register global shortcut '{ShortcutId}': {Error}", shortcutId, result?.ErrorMessage ?? "Unknown error");
+                return false;
+            }
+
+            this.logger?.LogInformation("Global shortcut '{ShortcutId}' registered successfully with key '{Shortcut}'.", shortcutId, shortcut);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            this.logger?.LogError(ex, "Exception while registering global shortcut '{ShortcutId}'.", shortcutId);
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Validates a shortcut string without registering it.
+    /// </summary>
+    /// <param name="shortcut">The shortcut string to validate.</param>
+    /// <returns>A validation result indicating if the shortcut is valid and any conflicts.</returns>
+    public async Task<ShortcutValidationResult> ValidateShortcut(string shortcut)
+    {
+        try
+        {
+            var request = new ValidateShortcutRequest(shortcut);
+            var response = await this.http.PostAsJsonAsync("/shortcuts/validate", request, this.jsonRustSerializerOptions);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                this.logger?.LogError("Failed to validate shortcut due to network error: {StatusCode}", response.StatusCode);
+                return new ShortcutValidationResult(false, "Network error during validation", false, string.Empty);
+            }
+
+            var result = await response.Content.ReadFromJsonAsync<ShortcutValidationResponse>(this.jsonRustSerializerOptions);
+            if (result is null)
+                return new ShortcutValidationResult(false, "Invalid response from server", false, string.Empty);
+
+            return new ShortcutValidationResult(result.IsValid, result.ErrorMessage, result.HasConflict, result.ConflictDescription);
+        }
+        catch (Exception ex)
+        {
+            this.logger?.LogError(ex, "Exception while validating shortcut.");
+            return new ShortcutValidationResult(false, ex.Message, false, string.Empty);
+        }
+    }
+
+    /// <summary>
+    /// Suspends shortcut processing. The shortcuts remain registered, but events are not sent.
+    /// This is useful when opening a dialog to configure shortcuts, so the user can
+    /// press the current shortcut to re-enter it without triggering the action.
+    /// </summary>
+    /// <returns>True if successful, false otherwise.</returns>
+    public async Task<bool> SuspendShortcutProcessing()
+    {
+        try
+        {
+            var response = await this.http.PostAsync("/shortcuts/suspend", null);
+            if (!response.IsSuccessStatusCode)
+            {
+                this.logger?.LogError("Failed to suspend the shortcut processing due to network error: {StatusCode}.", response.StatusCode);
+                return false;
+            }
+
+            var result = await response.Content.ReadFromJsonAsync<ShortcutResponse>(this.jsonRustSerializerOptions);
+            if (result is null || !result.Success)
+            {
+                this.logger?.LogError("Failed to suspend shortcut processing: {Error}", result?.ErrorMessage ?? "Unknown error");
+                return false;
+            }
+
+            this.logger?.LogDebug("Shortcut processing suspended.");
+            return true;
+        }
+        catch (Exception ex)
+        {
+            this.logger?.LogError(ex, "Exception while suspending shortcut processing.");
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Resumes the shortcut processing after it was suspended.
+    /// </summary>
+    /// <returns>True if successful, false otherwise.</returns>
+    public async Task<bool> ResumeShortcutProcessing()
+    {
+        try
+        {
+            var response = await this.http.PostAsync("/shortcuts/resume", null);
+            if (!response.IsSuccessStatusCode)
+            {
+                this.logger?.LogError("Failed to resume shortcut processing due to network error: {StatusCode}.", response.StatusCode);
+                return false;
+            }
+
+            var result = await response.Content.ReadFromJsonAsync<ShortcutResponse>(this.jsonRustSerializerOptions);
+            if (result is null || !result.Success)
+            {
+                this.logger?.LogError("Failed to resume shortcut processing: {Error}", result?.ErrorMessage ?? "Unknown error");
+                return false;
+            }
+
+            this.logger?.LogDebug("Shortcut processing resumed.");
+            return true;
+        }
+        catch (Exception ex)
+        {
+            this.logger?.LogError(ex, "Exception while resuming shortcut processing.");
+            return false;
+        }
+    }
+}

app/MindWork AI Studio/Tools/Services/RustService.cs

@@ -1,7 +1,6 @@
 using System.Security.Cryptography;
 using System.Text.Json;
 
-using AIStudio.Settings;
 using AIStudio.Tools.PluginSystem;
 
 using Version = System.Version;
@@ -22,7 +21,10 @@ public sealed partial class RustService : BackgroundService
     private readonly JsonSerializerOptions jsonRustSerializerOptions = new()
     {
         PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
-        Converters = { new TolerantEnumConverter() },
+        Converters =
+        {
+            new RustEnumConverter(),
+        },
     };
     
     private ILogger<RustService>? logger;