fix(native): resync stuck keys

Author: haritabh-z01

packages/native-helpers/swift-helper/Sources/SwiftHelper/KeycodeMap.swift

@@ -84,8 +84,23 @@ private let macOSKeycodeToKey: [Int: String] = [
     50: "`",
 ]
 
+/// Reverse lookup: key name to keycode
+private let macOSKeyToKeycode: [String: Int] = {
+    var reverse: [String: Int] = [:]
+    for (keyCode, name) in macOSKeycodeToKey {
+        reverse[name] = keyCode
+    }
+    return reverse
+}()
+
 /// Convert a macOS CGKeyCode to a key name string
 /// Returns nil if the keycode is not mapped
 func keyCodeToName(_ keyCode: Int) -> String? {
     return macOSKeycodeToKey[keyCode]
 }
+
+/// Convert a key name string to a macOS CGKeyCode
+/// Returns nil if the key name is not mapped
+func nameToKeyCode(_ name: String) -> Int? {
+    return macOSKeyToKeycode[name]
+}

packages/native-helpers/swift-helper/Sources/SwiftHelper/ShortcutManager.swift

@@ -1,3 +1,4 @@
+import CoreGraphics
 import Foundation
 
 /// Represents the state of modifier keys at a given moment
@@ -100,6 +101,50 @@ class ShortcutManager {
         pressedRegularKeys.remove(key)
     }
 
+    /// Check if a key is actually pressed using CGEventSource
+    private func isKeyActuallyPressed(_ keyCode: CGKeyCode) -> Bool {
+        return CGEventSource.keyState(.combinedSessionState, key: keyCode)
+    }
+
+    /// Validate all tracked key states against actual OS state.
+    /// Removes any keys that are not actually pressed (stuck keys).
+    /// Returns true if state was valid, false if corrections were made.
+    func validateAndResyncKeyState() -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+
+        var stateValid = true
+
+        // Validate Fn key state
+        // Fn key code is 0x3F (63)
+        let fnKeyCode: CGKeyCode = 0x3F
+        if fnKeyDown && !isKeyActuallyPressed(fnKeyCode) {
+            logToStderr("[ShortcutManager] Resync: Fn key was stuck, clearing")
+            fnKeyDown = false
+            stateValid = false
+        }
+
+        // Validate regular keys
+        var staleKeys: [String] = []
+        for keyName in pressedRegularKeys {
+            if let keyCode = nameToKeyCode(keyName) {
+                if !isKeyActuallyPressed(CGKeyCode(keyCode)) {
+                    staleKeys.append(keyName)
+                }
+            }
+        }
+
+        if !staleKeys.isEmpty {
+            for key in staleKeys {
+                pressedRegularKeys.remove(key)
+            }
+            logToStderr("[ShortcutManager] Resync: Regular keys were stuck, cleared: \(staleKeys)")
+            stateValid = false
+        }
+
+        return stateValid
+    }
+
     /// Check if this key event should be consumed (prevent default behavior)
     /// Called from event tap callback for keyDown/keyUp events only
     func shouldConsumeKey(keyCode: Int, modifiers: ModifierState) -> Bool {

packages/native-helpers/swift-helper/Sources/SwiftHelper/main.swift

@@ -84,6 +84,22 @@ func eventTapCallback(
         }
 
         if ShortcutManager.shared.shouldConsumeKey(keyCode: Int(keyCode), modifiers: modifiers) {
+            // Before consuming, validate that all tracked keys are actually pressed.
+            // This prevents stuck keys (missed keyUp events) from blocking input.
+            if !ShortcutManager.shared.validateAndResyncKeyState() {
+                // State was invalid (some keys were stuck), re-check with corrected state
+                let correctedModifiers = ModifierState(
+                    fn: event.flags.contains(.maskSecondaryFn),
+                    cmd: event.flags.contains(.maskCommand),
+                    ctrl: event.flags.contains(.maskControl),
+                    alt: event.flags.contains(.maskAlternate),
+                    shift: event.flags.contains(.maskShift)
+                )
+                if !ShortcutManager.shared.shouldConsumeKey(keyCode: Int(keyCode), modifiers: correctedModifiers) {
+                    // After correction, we should NOT consume - let the key through
+                    return Unmanaged.passRetained(event)
+                }
+            }
             // CONSUME - prevent default behavior (e.g., cursor movement for arrow keys)
             return nil
         }

packages/native-helpers/windows-helper/src/ShortcutManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.InteropServices;
 
 namespace WindowsHelper
 {
@@ -23,6 +24,9 @@ public struct ModifierState
     /// </summary>
     public class ShortcutManager
     {
+        [DllImport("user32.dll")]
+        private static extern short GetAsyncKeyState(int vKey);
+
         private static readonly Lazy<ShortcutManager> _instance = new(() => new ShortcutManager());
         public static ShortcutManager Instance => _instance.Value;
 
@@ -87,6 +91,41 @@ public void RemoveRegularKey(string key)
             }
         }
 
+        /// <summary>
+        /// Check if a key is actually pressed using GetAsyncKeyState.
+        /// </summary>
+        private bool IsKeyActuallyPressed(int vkCode)
+        {
+            // High-order bit is set if key is currently down
+            return (GetAsyncKeyState(vkCode) & 0x8000) != 0;
+        }
+
+        /// <summary>
+        /// Validate all tracked regular keys against actual OS state.
+        /// Removes any keys that are not actually pressed (stuck keys).
+        /// Returns the list of keys that were removed.
+        /// </summary>
+        public List<string> ValidateAndClearStaleKeys()
+        {
+            var staleKeys = new List<string>();
+
+            lock (_lock)
+            {
+                var keysToCheck = _pressedRegularKeys.ToList();
+                foreach (var keyName in keysToCheck)
+                {
+                    var vkCode = VirtualKeyMap.GetVkCode(keyName);
+                    if (vkCode.HasValue && !IsKeyActuallyPressed(vkCode.Value))
+                    {
+                        _pressedRegularKeys.Remove(keyName);
+                        staleKeys.Add(keyName);
+                    }
+                }
+            }
+
+            return staleKeys;
+        }
+
         /// <summary>
         /// Check if this key event should be consumed (prevent default behavior).
         /// Called from ShortcutMonitor hook callback for keyDown/keyUp events only.

packages/native-helpers/windows-helper/src/ShortcutMonitor.cs

@@ -32,6 +32,9 @@ public class ShortcutMonitor
         [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
         private static extern IntPtr GetModuleHandle(string lpModuleName);
 
+        [DllImport("user32.dll")]
+        private static extern short GetAsyncKeyState(int vKey);
+
         [StructLayout(LayoutKind.Sequential)]
         private struct KBDLLHOOKSTRUCT
         {
@@ -235,6 +238,26 @@ private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
 
                             if (ShortcutManager.Instance.ShouldConsumeKey((int)kbStruct.vkCode, modifierState))
                             {
+                                // Before consuming, validate that all tracked keys are actually pressed.
+                                // This prevents stuck keys (missed keyUp events) from blocking input system-wide.
+                                if (!ValidateKeyStateBeforeConsume())
+                                {
+                                    // State was invalid (some keys were stuck), re-check with corrected state
+                                    var correctedModifierState = new ModifierState
+                                    {
+                                        Win = winPressed,
+                                        Ctrl = ctrlPressed,
+                                        Alt = altPressed,
+                                        Shift = shiftPressed
+                                    };
+
+                                    if (!ShortcutManager.Instance.ShouldConsumeKey((int)kbStruct.vkCode, correctedModifierState))
+                                    {
+                                        // After correction, we should NOT consume - let the key through
+                                        return CallNextHookEx(hookId, nCode, wParam, lParam);
+                                    }
+                                }
+
                                 // Consume - prevent default behavior (e.g., cursor movement for arrow keys)
                                 return (IntPtr)1;
                             }
@@ -346,5 +369,84 @@ private void LogToStderr(string message)
             Console.Error.WriteLine($"[{timestamp}] [ShortcutMonitor] {message}");
             Console.Error.Flush();
         }
+
+        /// <summary>
+        /// Check if a key is actually pressed using GetAsyncKeyState.
+        /// </summary>
+        private bool IsKeyActuallyPressed(int vkCode)
+        {
+            // High-order bit is set if key is currently down
+            return (GetAsyncKeyState(vkCode) & 0x8000) != 0;
+        }
+
+        /// <summary>
+        /// Validate that all tracked key states match actual OS state.
+        /// If any key is not actually pressed, resync state and return false.
+        /// This prevents stuck keys from causing keys to be consumed incorrectly.
+        /// </summary>
+        private bool ValidateKeyStateBeforeConsume()
+        {
+            bool stateValid = true;
+
+            // Validate modifier keys
+            if (leftShiftPressed && !IsKeyActuallyPressed(VK_LSHIFT))
+            {
+                LogToStderr("Resync: leftShift was stuck, clearing");
+                leftShiftPressed = false;
+                stateValid = false;
+            }
+            if (rightShiftPressed && !IsKeyActuallyPressed(VK_RSHIFT))
+            {
+                LogToStderr("Resync: rightShift was stuck, clearing");
+                rightShiftPressed = false;
+                stateValid = false;
+            }
+            if (leftCtrlPressed && !IsKeyActuallyPressed(VK_LCONTROL))
+            {
+                LogToStderr("Resync: leftCtrl was stuck, clearing");
+                leftCtrlPressed = false;
+                stateValid = false;
+            }
+            if (rightCtrlPressed && !IsKeyActuallyPressed(VK_RCONTROL))
+            {
+                LogToStderr("Resync: rightCtrl was stuck, clearing");
+                rightCtrlPressed = false;
+                stateValid = false;
+            }
+            if (leftAltPressed && !IsKeyActuallyPressed(VK_LMENU))
+            {
+                LogToStderr("Resync: leftAlt was stuck, clearing");
+                leftAltPressed = false;
+                stateValid = false;
+            }
+            if (rightAltPressed && !IsKeyActuallyPressed(VK_RMENU))
+            {
+                LogToStderr("Resync: rightAlt was stuck, clearing");
+                rightAltPressed = false;
+                stateValid = false;
+            }
+            if (leftWinPressed && !IsKeyActuallyPressed(VK_LWIN))
+            {
+                LogToStderr("Resync: leftWin was stuck, clearing");
+                leftWinPressed = false;
+                stateValid = false;
+            }
+            if (rightWinPressed && !IsKeyActuallyPressed(VK_RWIN))
+            {
+                LogToStderr("Resync: rightWin was stuck, clearing");
+                rightWinPressed = false;
+                stateValid = false;
+            }
+
+            // Validate regular keys tracked in ShortcutManager
+            var staleKeys = ShortcutManager.Instance.ValidateAndClearStaleKeys();
+            if (staleKeys.Count > 0)
+            {
+                LogToStderr($"Resync: Regular keys were stuck, cleared: [{string.Join(", ", staleKeys)}]");
+                stateValid = false;
+            }
+
+            return stateValid;
+        }
     }
 }

packages/native-helpers/windows-helper/src/VirtualKeyMap.cs

@@ -25,6 +25,7 @@ public static class VirtualKeyMap
 
         private static readonly Dictionary<int, string> VkCodeToKey = new()
         {
+            // Note: Reverse lookup dictionary (KeyToVkCode) is auto-generated below
             // Letters (A-Z: 0x41-0x5A)
             { 0x41, "A" },
             { 0x42, "B" },
@@ -106,6 +107,18 @@ public static class VirtualKeyMap
             { 0xC0, "`" },      // VK_OEM_3
         };
 
+        // Reverse lookup: key name to VK code (auto-generated from VkCodeToKey)
+        private static readonly Dictionary<string, int> KeyToVkCode;
+
+        static VirtualKeyMap()
+        {
+            KeyToVkCode = new Dictionary<string, int>();
+            foreach (var kvp in VkCodeToKey)
+            {
+                KeyToVkCode[kvp.Value] = kvp.Key;
+            }
+        }
+
         /// <summary>
         /// Convert a Windows Virtual Key code to a key name string.
         /// Returns null if the keycode is not mapped.
@@ -114,5 +127,14 @@ public static class VirtualKeyMap
         {
             return VkCodeToKey.TryGetValue(vkCode, out var name) ? name : null;
         }
+
+        /// <summary>
+        /// Convert a key name string to a Windows Virtual Key code.
+        /// Returns null if the key name is not mapped.
+        /// </summary>
+        public static int? GetVkCode(string keyName)
+        {
+            return KeyToVkCode.TryGetValue(keyName, out var vkCode) ? vkCode : null;
+        }
     }
 }