whisper-key-local 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

whisper_key/hotkey_listener.py

@@ -1,12 +1,11 @@
 import logging
 
-from global_hotkeys import register_hotkeys, start_checking_hotkeys, stop_checking_hotkeys
-
+from .platform import hotkeys
 from .state_manager import StateManager
 
-class HotkeyListener:   
-    def __init__(self, state_manager: StateManager, recording_hotkey: str, 
-                 auto_enter_hotkey: str = None, auto_enter_enabled: bool = True, 
+class HotkeyListener:
+    def __init__(self, state_manager: StateManager, recording_hotkey: str,
+                 auto_enter_hotkey: str = None, auto_enter_enabled: bool = True,
                  stop_with_modifier_enabled: bool = False, cancel_combination: str = None):
         self.state_manager = state_manager
         self.recording_hotkey = recording_hotkey
@@ -14,38 +13,38 @@ class HotkeyListener:
         self.auto_enter_enabled = auto_enter_enabled
         self.stop_with_modifier_enabled = stop_with_modifier_enabled
         self.cancel_combination = cancel_combination
-        self.stop_modifier_hotkey = None  # Will be calculated from recording_hotkey
+        self.stop_modifier_hotkey = None
         self.modifier_key_released = True
         self.is_listening = False
         self.logger = logging.getLogger(__name__)
-        
+
         self._setup_hotkeys()
-        
+
         self.start_listening()
-    
+
     def _setup_hotkeys(self):
         hotkey_configs = []
-        
+
         hotkey_configs.append({
             'combination': self.recording_hotkey,
             'callback': self._standard_hotkey_pressed,
             'name': 'standard'
         })
-        
+
         if self.auto_enter_enabled and self.auto_enter_hotkey:
             hotkey_configs.append({
                 'combination': self.auto_enter_hotkey,
                 'callback': self._auto_enter_hotkey_pressed,
                 'name': 'auto-enter'
             })
-        
+
         if self.cancel_combination:
             hotkey_configs.append({
                 'combination': self.cancel_combination,
                 'callback': self._cancel_hotkey_pressed,
                 'name': 'cancel'
             })
-        
+
         if self.stop_with_modifier_enabled:
             self.stop_modifier_hotkey = self._extract_first_modifier(self.recording_hotkey)
             if self.stop_modifier_hotkey:
@@ -55,151 +54,118 @@ class HotkeyListener:
                     'release_callback': self._arm_stop_modifier_hotkey_on_release,
                     'name': 'stop-modifier'
                 })
-        
-        # More modifiers = higher priority
+
         hotkey_configs.sort(key=self._get_hotkey_combination_specificity, reverse=True)
-        
+
         self.hotkey_bindings = []
         for config in hotkey_configs:
-            formatted_hotkey = self._convert_hotkey_to_global_hotkeys_format(config['combination'])
-            
-            # Setup for global-hotkeys
-            # Expected format: [hotkey, press_callback, release_callback, actuate_on_partial_release]
+            hotkey = config['combination'].lower().strip()
             self.hotkey_bindings.append([
-                                         formatted_hotkey,
-                                         config['callback'],
-                                         config.get('release_callback') or None,
-                                         False])
+                hotkey,
+                config['callback'],
+                config.get('release_callback') or None,
+                False
+            ])
+            self.logger.info(f"Configured {config['name']} hotkey: {hotkey}")
 
-            self.logger.info(f"Configured {config['name']} hotkey: {config['combination']} -> {formatted_hotkey}")
-        
         self.logger.info(f"Total hotkeys configured: {len(self.hotkey_bindings)}")
-    
+
     def _get_hotkey_combination_specificity(self, hotkey_config: dict) -> int:
-        """
-        Returns specificity score to ensure combos with more keys take priority
-        """
         combination = hotkey_config['combination'].lower()
         return len(combination.split('+'))
-    
+
     def _standard_hotkey_pressed(self):
         self.logger.info(f"Standard hotkey pressed: {self.recording_hotkey}")
-        
-        # Disable stop-modifier until key is released (prevents immediate stopping)
+
         self.modifier_key_released = False
-        
+
         self.state_manager.toggle_recording()
-    
+
     def _auto_enter_hotkey_pressed(self):
         self.logger.info(f"Auto-enter hotkey pressed: {self.auto_enter_hotkey}")
-        
+
         if not self.state_manager.audio_recorder.get_recording_status():
             self.logger.debug("Auto-enter hotkey ignored - not currently recording")
             return
-        
+
         if not self.state_manager.clipboard_manager.auto_paste:
             self.logger.debug("Auto-enter hotkey ignored - auto-paste is disabled")
             return
-        
+
         if self.stop_with_modifier_enabled and not self.modifier_key_released:
             self.logger.debug("Auto-enter hotkey ignored - waiting for modifier key release")
             return
-        
-        # Disable stop-modifier until key is released
+
         self.modifier_key_released = False
-        
+
         self.state_manager.stop_recording(use_auto_enter=True)
-    
+
     def _cancel_hotkey_pressed(self):
         self.logger.info(f"Cancel hotkey pressed: {self.cancel_combination}")
         self.state_manager.cancel_recording_hotkey_pressed()
-    
+
     def _stop_modifier_hotkey_pressed(self):
         self.logger.debug(f"Stop-modifier hotkey pressed: {self.stop_modifier_hotkey}, modifier_released={self.modifier_key_released}")
-        
-        # Only stop if the modifier key has been released since last full hotkey press
+
         if self.modifier_key_released:
             self.logger.info(f"Stop-modifier hotkey activated: {self.stop_modifier_hotkey}")
             self.state_manager.stop_recording()
         else:
             self.logger.debug("Stop-modifier ignored - waiting for key release first")
-    
+
     def _arm_stop_modifier_hotkey_on_release(self):
         self.logger.debug(f"Stop-modifier key released: {self.stop_modifier_hotkey}")
         self.modifier_key_released = True
-        
+
     def _extract_first_modifier(self, hotkey_str: str) -> str:
         parts = hotkey_str.lower().split('+')
         if len(parts) > 1:
             return parts[0].strip()
         return None
-    
+
     def start_listening(self):
         if self.is_listening:
             return
-        
-        try:            
-            register_hotkeys(self.hotkey_bindings)        
-            start_checking_hotkeys()
+
+        try:
+            hotkeys.register(self.hotkey_bindings)
+            hotkeys.start()
             self.is_listening = True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to start hotkey listener: {e}")
             raise
-    
+
     def stop_listening(self):
         if not self.is_listening:
             return
-        
+
         try:
-            stop_checking_hotkeys()            
+            hotkeys.stop()
             self.is_listening = False
             self.logger.info("Hotkey listener stopped")
-            
+
         except Exception as e:
             self.logger.error(f"Error stopping hotkey listener: {e}")
-    
-    def _convert_hotkey_to_global_hotkeys_format(self, hotkey_str: str) -> str:
-
-        key_mapping = {
-            'ctrl': 'control',
-            'shift': 'shift',
-            'alt': 'alt',
-            'win': 'window',
-            'windows': 'window',
-            'cmd': 'window',
-            'super': 'window',
-            'space': 'space',
-            'enter': 'enter',
-            'esc': 'escape'
-        }
-        
-        keys = hotkey_str.lower().split('+')
-        converted_keys = []
-        
-        for key in keys:
-            key = key.strip()
-            converted_keys.append(key_mapping.get(key, key))
-        
-        return ' + '.join(converted_keys)    
-    
+
+
     def change_hotkey_config(self, setting: str, value):
         valid_settings = ['recording_hotkey', 'auto_enter_hotkey', 'auto_enter_enabled', 'stop_with_modifier_enabled', 'cancel_combination']
-        
+
         if setting not in valid_settings:
             raise ValueError(f"Invalid setting '{setting}'. Valid options: {valid_settings}")
-        
+
         old_value = getattr(self, setting)
-        
+
         if old_value == value:
             return
-        
+
         setattr(self, setting, value)
         self.logger.info(f"Changed {setting}: {old_value} -> {value}")
-        
+
         self.stop_listening()
         self._setup_hotkeys()
         self.start_listening()
-    
+
     def is_active(self) -> bool:
-        return self.is_listening
+        return self.is_listening

whisper_key/instance_manager.py

@@ -2,35 +2,31 @@ import logging
 import sys
 import time
 
-import win32api
-import win32event
+from .platform import instance_lock
 
 logger = logging.getLogger(__name__)
 
 def guard_against_multiple_instances(app_name: str = "WhisperKeyLocal"):
-    mutex_name = f"{app_name}_SingleInstance"
-    
     try:
-        mutex_handle = win32event.CreateMutex(None, True, mutex_name)
-        
-        if win32api.GetLastError() == 183:  # ERROR_ALREADY_EXISTS
+        mutex_handle = instance_lock.acquire_lock(app_name)
+
+        if mutex_handle is None:
             logger.info("Another instance detected")
             _exit_to_prevent_duplicate()
         else:
             logger.info("Primary instance acquired mutex")
-            # Return the mutex handle so it stays alive until app exits
             return mutex_handle
-            
+
     except Exception as e:
         logger.error(f"Error with single instance check: {e}")
         raise
 
 def _exit_to_prevent_duplicate():
-    print("\nWhisper Key is already running!")       
+    print("\nWhisper Key is already running!")
     print("\nThis app will close in 3 seconds...")
-    
+
     for i in range(3, 0, -1):
         time.sleep(1)
-    
+
     print("\nGoodbye!")
-    sys.exit(0)
+    sys.exit(0)

whisper_key/main.py

@@ -3,12 +3,16 @@
 from .utils import add_portaudio_dll_to_search_path
 add_portaudio_dll_to_search_path()
 
+import argparse
 import logging
 import os
 import signal
 import sys
 import threading
 
+sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+
+from .platform import app, permissions
 from .config_manager import ConfigManager
 from .audio_recorder import AudioRecorder
 from .hotkey_listener import HotkeyListener
@@ -127,7 +131,7 @@ def setup_system_tray(tray_config, config_manager, state_manager, model_registry
 def setup_signal_handlers(shutdown_event):
     def signal_handler(signum, frame):
         shutdown_event.set()
-    
+
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
 
@@ -142,21 +146,28 @@ def setup_hotkey_listener(hotkey_config, state_manager):
     )
 
 def shutdown_app(hotkey_listener: HotkeyListener, state_manager: StateManager, logger: logging.Logger):
-    # Stop hotkey listener first to prevent new events during shutdown
     try:
         if hotkey_listener and hotkey_listener.is_active():
             logger.info("Stopping hotkey listener...")
             hotkey_listener.stop_listening()
     except Exception as ex:
         logger.error(f"Error stopping hotkey listener: {ex}")
-    
+
     if state_manager:
         state_manager.shutdown()
 
-def main():   
-    mutex_handle = guard_against_multiple_instances()
-    
-    print(f"Starting Whisper Key [{get_version()}]... Local Speech-to-Text App...")
+def main():
+    app.setup()
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--test', action='store_true', help='Run as separate test instance')
+    args = parser.parse_args()
+
+    instance_name = "WhisperKeyLocal_test" if args.test else "WhisperKeyLocal"
+    mutex_handle = guard_against_multiple_instances(instance_name)
+
+    mode_label = " [TEST]" if args.test else ""
+    print(f"Starting Whisper Key [{get_version()}]{mode_label}... Local Speech-to-Text App...")
     
     shutdown_event = threading.Event()
     setup_signal_handlers(shutdown_event)
@@ -204,14 +215,20 @@ def main():
         state_manager.attach_components(audio_recorder, system_tray)
         
         hotkey_listener = setup_hotkey_listener(hotkey_config, state_manager)
-        
+
         system_tray.start()
 
-        print(f"🚀 Application ready! Press {beautify_hotkey(hotkey_config['recording_hotkey'])} to start recording.")
+        print(f"🚀 Application ready! Press [{beautify_hotkey(hotkey_config['recording_hotkey'])}] to start recording.", flush=True)  # flush so headless agent can detect startup success
         print("Press Ctrl+C to quit.")
 
-        while not shutdown_event.wait(timeout=0.1):
-            pass
+        if clipboard_config['auto_paste']:
+            if not permissions.check_accessibility_permission():
+                if not permissions.handle_missing_permission(config_manager):
+                    app.run_event_loop(shutdown_event)
+                    return
+                clipboard_manager.update_auto_paste(False)
+
+        app.run_event_loop(shutdown_event)
             
     except KeyboardInterrupt:
         logger.info("Application shutting down...")

whisper_key/platform/__init__.py

@@ -0,0 +1,10 @@
+import platform as _platform
+
+PLATFORM = 'macos' if _platform.system() == 'Darwin' else 'windows'
+IS_MACOS = PLATFORM == 'macos'
+IS_WINDOWS = PLATFORM == 'windows'
+
+if IS_MACOS:
+    from .macos import instance_lock, console, keyboard, hotkeys, paths, app, permissions, icons
+else:
+    from .windows import instance_lock, console, keyboard, hotkeys, paths, app, permissions, icons

whisper_key/platform/macos/__init__.py

@@ -0,0 +1 @@
+from . import instance_lock, console, keyboard, hotkeys, paths, permissions

whisper_key/platform/macos/app.py

@@ -0,0 +1,27 @@
+from AppKit import NSApplication, NSApplicationActivationPolicyAccessory, NSEventMaskAny, NSDefaultRunLoopMode
+from Foundation import NSDate, NSObject
+
+class AppDelegate(NSObject):
+    def applicationSupportsSecureRestorableState_(self, app):
+        return True
+
+_delegate = None
+
+def setup():
+    global _delegate
+    app = NSApplication.sharedApplication()
+    app.setActivationPolicy_(NSApplicationActivationPolicyAccessory)
+    _delegate = AppDelegate.alloc().init()
+    app.setDelegate_(_delegate)
+
+def run_event_loop(shutdown_event):
+    app = NSApplication.sharedApplication()
+    while not shutdown_event.is_set():
+        event = app.nextEventMatchingMask_untilDate_inMode_dequeue_(
+            NSEventMaskAny,
+            NSDate.dateWithTimeIntervalSinceNow_(0.1),
+            NSDefaultRunLoopMode,
+            True
+        )
+        if event:
+            app.sendEvent_(event)

whisper_key/platform/macos/console.py

@@ -0,0 +1,13 @@
+import logging
+
+class ConsoleManager:
+    def __init__(self, config: dict, is_executable_mode: bool = False):
+        self.logger = logging.getLogger(__name__)
+        self.config = config
+        self.is_executable_mode = is_executable_mode
+
+    def show_console(self):
+        return True
+
+    def hide_console(self):
+        return True

whisper_key/platform/macos/hotkeys.py

@@ -0,0 +1,180 @@
+import logging
+import threading
+from dataclasses import dataclass, field
+from typing import Callable
+
+from AppKit import NSEvent
+
+from .keycodes import KEY_CODES
+
+logger = logging.getLogger(__name__)
+
+NSKeyDownMask = 1 << 10
+NSFlagsChangedMask = 1 << 12
+
+MODIFIER_FLAGS = {
+    'ctrl': 1 << 18,
+    'control': 1 << 18,
+    'cmd': 1 << 20,
+    'command': 1 << 20,
+    'option': 1 << 19,
+    'alt': 1 << 19,
+    'shift': 1 << 17,
+    'fn': 1 << 23,
+    'function': 1 << 23,
+}
+
+MODIFIER_MASK = (1 << 18) | (1 << 20) | (1 << 19) | (1 << 17) | (1 << 23)
+
+
+@dataclass
+class ParsedBinding:
+    original: str
+    modifiers: int
+    keycode: int | None
+    press_callback: Callable
+    release_callback: Callable | None
+    is_active: bool = field(default=False)
+
+
+class ModifierStateTracker:
+    def __init__(self):
+        self.previous_flags = 0
+
+    def update(self, new_flags: int) -> tuple[int, int, int, int]:
+        new_flags = new_flags & MODIFIER_MASK
+        old_flags = self.previous_flags
+        pressed = new_flags & ~old_flags
+        released = old_flags & ~new_flags
+        self.previous_flags = new_flags
+        return old_flags, new_flags, pressed, released
+
+    def reset(self):
+        self.previous_flags = 0
+
+
+_monitor = None
+_bindings: list[ParsedBinding] = []
+_state = ModifierStateTracker()
+
+
+def _parse_hotkey_string(hotkey_str: str) -> tuple[int, int | None]:
+    parts = [p.strip().lower() for p in hotkey_str.split('+')]
+
+    modifiers = 0
+    keycode = None
+
+    for part in parts:
+        if part in ('win', 'window', 'windows', 'super'):
+            continue
+
+        if part in MODIFIER_FLAGS:
+            modifiers |= MODIFIER_FLAGS[part]
+        elif part in KEY_CODES:
+            keycode = KEY_CODES[part]
+        else:
+            logger.warning(f"Unknown key in hotkey string: {part}")
+
+    return modifiers, keycode
+
+
+def _parse_binding(binding: list) -> ParsedBinding:
+    hotkey_str = binding[0]
+    press_cb = binding[1]
+    release_cb = binding[2] if len(binding) > 2 else None
+
+    modifiers, keycode = _parse_hotkey_string(hotkey_str)
+
+    return ParsedBinding(
+        original=hotkey_str,
+        modifiers=modifiers,
+        keycode=keycode,
+        press_callback=press_cb,
+        release_callback=release_cb,
+    )
+
+
+def _handle_flags_changed(event):
+    old_flags, new_flags, pressed, released = _state.update(event.modifierFlags())
+
+    for binding in _bindings:
+        if binding.keycode is not None:
+            continue
+
+        if new_flags == binding.modifiers and old_flags != binding.modifiers:
+            logger.debug(f"Modifier-only hotkey pressed: {binding.original}")
+            binding.is_active = True
+            try:
+                threading.Thread(target=binding.press_callback, daemon=True).start()
+            except Exception as e:
+                logger.error(f"Error in press callback for {binding.original}: {e}")
+
+        elif binding.is_active and (released & binding.modifiers):
+            logger.debug(f"Modifier-only hotkey released: {binding.original}")
+            binding.is_active = False
+            if binding.release_callback:
+                try:
+                    threading.Thread(target=binding.release_callback, daemon=True).start()
+                except Exception as e:
+                    logger.error(f"Error in release callback for {binding.original}: {e}")
+
+
+def _handle_key_down(event):
+    current_flags = event.modifierFlags() & MODIFIER_MASK
+    key_code = event.keyCode()
+
+    logger.debug(f"KeyDown: keycode={key_code}, flags={current_flags:#x}")
+
+    for binding in _bindings:
+        if binding.keycode is None:
+            continue
+
+        if key_code == binding.keycode and current_flags == binding.modifiers:
+            logger.debug(f"Traditional hotkey pressed: {binding.original}")
+            try:
+                threading.Thread(target=binding.press_callback, daemon=True).start()
+            except Exception as e:
+                logger.error(f"Error in press callback for {binding.original}: {e}")
+            return
+
+
+def _handle_event(event):
+    event_type = event.type()
+
+    if event_type == 12:  # NSFlagsChanged
+        _handle_flags_changed(event)
+    elif event_type == 10:  # NSKeyDown
+        _handle_key_down(event)
+
+
+def register(bindings: list):
+    global _bindings
+    _bindings = [_parse_binding(b) for b in bindings]
+    logger.info(f"Registered {len(_bindings)} hotkey bindings")
+    for b in _bindings:
+        binding_type = "modifier-only" if b.keycode is None else "traditional"
+        logger.debug(f"  {b.original} -> modifiers={b.modifiers:#x}, keycode={b.keycode} ({binding_type})")
+
+
+def start():
+    global _monitor
+    _state.reset()
+
+    mask = NSKeyDownMask | NSFlagsChangedMask
+    _monitor = NSEvent.addGlobalMonitorForEventsMatchingMask_handler_(mask, _handle_event)
+
+    if _monitor is None:
+        logger.error("Failed to create event monitor - check Accessibility permissions in System Settings > Privacy & Security > Accessibility")
+    else:
+        logger.info("NSEvent hotkey monitor started")
+
+
+def stop():
+    global _monitor
+    if _monitor:
+        NSEvent.removeMonitor_(_monitor)
+        _monitor = None
+        logger.info("NSEvent hotkey monitor stopped")
+
+    for binding in _bindings:
+        binding.is_active = False

whisper_key/platform/macos/icons.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+from PIL import Image
+
+ASSETS_DIR = Path(__file__).parent / "assets"
+
+def get_tray_icons() -> dict:
+    return {
+        "idle": Image.open(ASSETS_DIR / "tray_idle.png"),
+        "recording": Image.open(ASSETS_DIR / "tray_recording.png"),
+        "processing": Image.open(ASSETS_DIR / "tray_processing.png"),
+    }

whisper_key/platform/macos/instance_lock.py

@@ -0,0 +1,31 @@
+import fcntl
+import os
+from pathlib import Path
+
+_lock_file = None
+
+def acquire_lock(app_name: str):
+    global _lock_file
+    lock_path = Path.home() / f".{app_name}.lock"
+
+    try:
+        _lock_file = open(lock_path, 'w')
+        fcntl.flock(_lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        _lock_file.write(str(os.getpid()))
+        _lock_file.flush()
+        return _lock_file
+    except (IOError, OSError):
+        if _lock_file:
+            _lock_file.close()
+            _lock_file = None
+        return None
+
+def release_lock(handle):
+    global _lock_file
+    if handle:
+        try:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+            handle.close()
+        except:
+            pass
+    _lock_file = None