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

whisper_key/platform/macos/keyboard.py

@@ -0,0 +1,97 @@
+import logging
+import time
+
+from .keycodes import KEY_CODES
+
+logger = logging.getLogger(__name__)
+
+_delay = 0.0
+MODIFIER_FLAGS = {}
+
+try:
+    from Quartz import (
+        CGEventCreateKeyboardEvent,
+        CGEventPost,
+        CGEventSetFlags,
+        kCGHIDEventTap,
+        kCGEventFlagMaskCommand,
+        kCGEventFlagMaskControl,
+        kCGEventFlagMaskShift,
+        kCGEventFlagMaskAlternate,
+    )
+    _quartz_available = True
+    MODIFIER_FLAGS = {
+        'cmd': kCGEventFlagMaskCommand,
+        'command': kCGEventFlagMaskCommand,
+        'ctrl': kCGEventFlagMaskControl,
+        'control': kCGEventFlagMaskControl,
+        'shift': kCGEventFlagMaskShift,
+        'option': kCGEventFlagMaskAlternate,
+        'alt': kCGEventFlagMaskAlternate,
+    }
+except ImportError:
+    _quartz_available = False
+    logger.warning("Quartz not available - keyboard simulation disabled")
+
+
+def set_delay(delay: float):
+    global _delay
+    _delay = delay
+    logger.debug(f"Keyboard delay set to {delay}s")
+
+
+def send_key(key: str):
+    if not _quartz_available:
+        logger.warning("Cannot send key - Quartz not available")
+        return
+
+    key_lower = key.lower()
+    key_code = KEY_CODES.get(key_lower)
+    if key_code is None:
+        logger.error(f"Unknown key: {key}")
+        return
+
+    logger.debug(f"Sending key: {key} (code: {hex(key_code)})")
+
+    event = CGEventCreateKeyboardEvent(None, key_code, True)
+    CGEventSetFlags(event, 0)
+    CGEventPost(kCGHIDEventTap, event)
+
+    if _delay > 0:
+        time.sleep(_delay)
+
+    event = CGEventCreateKeyboardEvent(None, key_code, False)
+    CGEventSetFlags(event, 0)
+    CGEventPost(kCGHIDEventTap, event)
+
+
+def send_hotkey(*keys: str):
+    if not _quartz_available:
+        logger.warning("Cannot send hotkey - Quartz not available")
+        return
+
+    modifiers = [k for k in keys if k.lower() in MODIFIER_FLAGS]
+    regular_keys = [k for k in keys if k.lower() not in MODIFIER_FLAGS]
+
+    flags = 0
+    for mod in modifiers:
+        flags |= MODIFIER_FLAGS[mod.lower()]
+
+    logger.debug(f"Sending hotkey: {'+'.join(keys)} (modifiers: {modifiers}, keys: {regular_keys})")
+
+    for key in regular_keys:
+        key_code = KEY_CODES.get(key.lower())
+        if key_code is None:
+            logger.error(f"Unknown key in hotkey: {key}")
+            continue
+
+        event = CGEventCreateKeyboardEvent(None, key_code, True)
+        CGEventSetFlags(event, flags)
+        CGEventPost(kCGHIDEventTap, event)
+
+        if _delay > 0:
+            time.sleep(_delay)
+
+        event = CGEventCreateKeyboardEvent(None, key_code, False)
+        CGEventSetFlags(event, flags)
+        CGEventPost(kCGHIDEventTap, event)

whisper_key/platform/macos/keycodes.py

@@ -0,0 +1,17 @@
+KEY_CODES = {
+    'a': 0, 'b': 11, 'c': 8, 'd': 2, 'e': 14, 'f': 3, 'g': 5, 'h': 4,
+    'i': 34, 'j': 38, 'k': 40, 'l': 37, 'm': 46, 'n': 45, 'o': 31, 'p': 35,
+    'q': 12, 'r': 15, 's': 1, 't': 17, 'u': 32, 'v': 9, 'w': 13, 'x': 7,
+    'y': 16, 'z': 6,
+    '0': 29, '1': 18, '2': 19, '3': 20, '4': 21,
+    '5': 23, '6': 22, '7': 26, '8': 28, '9': 25,
+    'space': 49,
+    'enter': 36, 'return': 36,
+    'tab': 48,
+    'delete': 51, 'backspace': 51,
+    'escape': 53, 'esc': 53,
+    'f1': 122, 'f2': 120, 'f3': 99, 'f4': 118, 'f5': 96, 'f6': 97,
+    'f7': 98, 'f8': 100, 'f9': 101, 'f10': 109, 'f11': 103, 'f12': 111,
+    '.': 47, ',': 43, '/': 44, ';': 41, "'": 39, '[': 33, ']': 30,
+    '-': 27, '=': 24, '`': 50, '\\': 42,
+}

whisper_key/platform/macos/paths.py

@@ -0,0 +1,8 @@
+import subprocess
+from pathlib import Path
+
+def get_app_data_path():
+    return Path.home() / 'Library' / 'Application Support' / 'whisperkey'
+
+def open_file(path):
+    subprocess.run(['open', str(path)])

whisper_key/platform/macos/permissions.py

@@ -0,0 +1,66 @@
+import logging
+import os
+import signal
+import sys
+
+logger = logging.getLogger(__name__)
+
+try:
+    from ApplicationServices import AXIsProcessTrusted, AXIsProcessTrustedWithOptions
+    _appservices_available = True
+except ImportError:
+    _appservices_available = False
+    logger.warning("ApplicationServices not available - permission checks disabled")
+
+
+def _get_terminal_app_name() -> str:
+    term_program = os.environ.get('TERM_PROGRAM', '')
+    if 'iTerm' in term_program:
+        return 'iTerm'
+    elif term_program == 'Apple_Terminal':
+        return 'Terminal'
+    elif term_program:
+        return term_program.replace('.app', '')
+    return 'your terminal app'
+
+
+def check_accessibility_permission() -> bool:
+    if not _appservices_available:
+        return True
+    return AXIsProcessTrusted()
+
+
+def request_accessibility_permission():
+    if not _appservices_available:
+        return
+    options = {'AXTrustedCheckOptionPrompt': True}
+    AXIsProcessTrustedWithOptions(options)
+
+
+def handle_missing_permission(config_manager) -> bool:
+    from ...terminal_ui import prompt_choice
+
+    app_name = _get_terminal_app_name()
+
+    title = "Auto-paste requires permission to simulate [Cmd+V] keypress..."
+    options = [
+        (f"Grant accessibility permission to {app_name}", "Transcribe directly to cursor, with option to auto-send"),
+        ("Disable auto-paste", "Transcribe to clipboard, then manually paste"),
+    ]
+
+    choice = prompt_choice(title, options)
+
+    if choice == 1:
+        config_manager.update_user_setting('clipboard', 'auto_paste', True)
+        request_accessibility_permission()
+        print()
+        print("Please restart Whisper Key after permission is granted")
+        os.kill(os.getpid(), signal.SIGINT)
+        return False
+    elif choice == 2:
+        config_manager.update_user_setting('clipboard', 'auto_paste', False)
+        print()
+        return True
+    else:
+        os.kill(os.getpid(), signal.SIGINT)
+        return False

whisper_key/platform/windows/__init__.py

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

whisper_key/platform/windows/app.py

@@ -0,0 +1,6 @@
+def setup():
+    pass
+
+def run_event_loop(shutdown_event):
+    while not shutdown_event.wait(timeout=0.1):
+        pass

whisper_key/platform/windows/console.py

@@ -0,0 +1,59 @@
+import win32console
+import win32gui
+import win32con
+import logging
+import threading
+import time
+
+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
+        self.console_handle = None
+        self._lock = threading.Lock()
+
+        try:
+            self.console_handle = self._get_console_window()
+        except Exception as e:
+            self.logger.error(f"Failed to initialize console manager: {e}")
+
+        self._hide_on_startup()
+
+    def _get_console_window(self):
+        try:
+            handle = win32console.GetConsoleWindow()
+            if handle:
+                self.logger.debug(f"Console window handle: {handle}")
+                return handle
+            else:
+                self.logger.warning("GetConsoleWindow returned null handle")
+                return None
+        except Exception as e:
+            self.logger.error(f"Failed to get console window: {e}")
+            return None
+
+    def _hide_on_startup(self):
+        if self.config.get('start_hidden', False) and self.is_executable_mode:
+            time.sleep(2)
+            self.hide_console()
+
+    def show_console(self):
+        with self._lock:
+            try:
+                win32gui.ShowWindow(self.console_handle, win32con.SW_HIDE)
+                win32gui.ShowWindow(self.console_handle, win32con.SW_RESTORE)
+                win32gui.SetForegroundWindow(self.console_handle)
+                return True
+            except Exception as e:
+                self.logger.error(f"Failed to show/focus console: {e}")
+                return False
+
+    def hide_console(self):
+        with self._lock:
+            try:
+                win32gui.ShowWindow(self.console_handle, win32con.SW_HIDE)
+                return True
+            except Exception as e:
+                self.logger.error(f"Failed to hide console: {e}")
+                return False

whisper_key/platform/windows/hotkeys.py

@@ -0,0 +1,30 @@
+from global_hotkeys import register_hotkeys, start_checking_hotkeys, stop_checking_hotkeys
+
+# global-hotkeys library expects: 'control + window + shift' format
+KEY_MAP = {
+    'ctrl': 'control',
+    'win': 'window',
+    'windows': 'window',
+    'cmd': 'window',
+    'super': 'window',
+    'esc': 'escape',
+}
+
+def _normalize_hotkey(hotkey_str: str) -> str:
+    keys = hotkey_str.lower().split('+')
+    converted = [KEY_MAP.get(k.strip(), k.strip()) for k in keys]
+    return ' + '.join(converted)
+
+def register(bindings: list):
+    normalized = []
+    for binding in bindings:
+        hotkey_str = binding[0]
+        normalized_binding = [_normalize_hotkey(hotkey_str)] + binding[1:]
+        normalized.append(normalized_binding)
+    register_hotkeys(normalized)
+
+def start():
+    start_checking_hotkeys()
+
+def stop():
+    stop_checking_hotkeys()

whisper_key/platform/windows/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/windows/instance_lock.py

@@ -0,0 +1,14 @@
+import win32api
+import win32event
+
+def acquire_lock(app_name: str):
+    mutex_name = f"{app_name}_SingleInstance"
+    mutex_handle = win32event.CreateMutex(None, True, mutex_name)
+
+    if win32api.GetLastError() == 183:  # ERROR_ALREADY_EXISTS
+        return None
+
+    return mutex_handle
+
+def release_lock(handle):
+    pass  # Mutex is released automatically when process exits

whisper_key/platform/windows/keyboard.py

@@ -0,0 +1,12 @@
+import pyautogui
+
+pyautogui.FAILSAFE = True
+
+def set_delay(delay: float):
+    pyautogui.PAUSE = delay
+
+def send_hotkey(*keys: str):
+    pyautogui.hotkey(*keys)
+
+def send_key(key: str):
+    pyautogui.press(key)

whisper_key/platform/windows/paths.py

@@ -0,0 +1,8 @@
+import os
+from pathlib import Path
+
+def get_app_data_path():
+    return Path(os.getenv('APPDATA')) / 'whisperkey'
+
+def open_file(path):
+    os.startfile(path)

whisper_key/platform/windows/permissions.py

@@ -0,0 +1,6 @@
+def check_accessibility_permission() -> bool:
+    return True
+
+
+def handle_missing_permission(config_manager) -> bool:
+    return True

whisper_key/state_manager.py

@@ -127,13 +127,13 @@ class StateManager:
             
             duration = self.audio_recorder.get_audio_duration(audio_data)
             print(f"🎤 Recorded {duration:.1f} seconds! Transcribing...")
-            
+
+            self.system_tray.update_state("processing")
+
             transcribed_text = self.whisper_engine.transcribe_audio(audio_data)
-            
+
             if not transcribed_text:
                 return
-            
-            self.system_tray.update_state("processing")
 
             success = self.clipboard_manager.deliver_transcription(
                 transcribed_text, use_auto_enter

whisper_key/system_tray.py

@@ -1,11 +1,11 @@
 import logging
-import threading
 import os
 import signal
 from typing import Optional, TYPE_CHECKING
 from pathlib import Path
 
-from .utils import resolve_asset_path
+from .utils import open_file
+from .platform import permissions, icons
 
 try:
     import pystray
@@ -36,7 +36,6 @@ class SystemTray:
         self.icon = None  # pystray object, holds menu, state, etc.
         self.is_running = False
         self.current_state = "idle"
-        self.thread = None
         self.available = True
         
         if self._check_tray_availability():
@@ -46,7 +45,7 @@ class SystemTray:
         if not self.tray_config['enabled']:
             self.logger.warning("   ✗ System tray disabled in configuration")
             self.available = False
-            
+
         elif not TRAY_AVAILABLE:
             self.logger.warning("   ✗ System tray not available - pystray or Pillow not installed")
             self.available = False
@@ -55,31 +54,14 @@ class SystemTray:
     
     def _load_icons_to_cache(self):
         try:
-            self.icons = {}
-            
-            icon_files = {
-                "idle": "assets/tray_idle.png",
-                "recording": "assets/tray_recording.png", 
-                "processing": "assets/tray_processing.png"
-            }
-            
-            for state, asset_path in icon_files.items():
-                icon_path = Path(resolve_asset_path(asset_path))
-                
-                try:
-                    if icon_path.exists():
-                        self.icons[state] = Image.open(str(icon_path))
-                    else:
-                        self.icons[state] = self._create_fallback_icon(state)
-                        self.logger.warning(f"Icon file not found, using fallback: {icon_path}")
-                        
-                except Exception as e:
-                    self.logger.error(f"Failed to load icon {icon_path}: {e}")
-                    self.icons[state] = self._create_fallback_icon(state)
-
+            self.icons = icons.get_tray_icons()
         except Exception as e:
-            self.logger.error(f"Failed to load system tray: {e}")
-            self.available = False
+            self.logger.error(f"Failed to load tray icons: {e}")
+            self.icons = {
+                "idle": self._create_fallback_icon("idle"),
+                "recording": self._create_fallback_icon("recording"),
+                "processing": self._create_fallback_icon("processing"),
+            }
         
     def _create_fallback_icon(self, state: str) -> Image.Image:
         colors = {
@@ -235,7 +217,7 @@ class SystemTray:
         try:
             print("⚙️ Opening log file...")
             log_path = self.config_manager.get_log_file_path()
-            os.startfile(log_path)
+            open_file(log_path)
         except Exception as e:
             self.logger.error(f"Failed to open log file: {e}")
 
@@ -243,11 +225,17 @@ class SystemTray:
         try:
             print("⚙️ Opening settings...")
             config_path = self.config_manager.user_settings_path
-            os.startfile(config_path)
+            open_file(config_path)
         except Exception as e:
             self.logger.error(f"Failed to open config file: {e}")
 
-    def _set_transcription_mode(self, auto_paste: bool):        
+    def _set_transcription_mode(self, auto_paste: bool):
+        if auto_paste:
+            if not permissions.check_accessibility_permission():
+                if not permissions.handle_missing_permission(self.config_manager):
+                    return
+                auto_paste = False
+
         self.state_manager.update_transcription_mode(auto_paste)
         self.icon.menu = self._create_menu()
 
@@ -307,58 +295,43 @@ class SystemTray:
         except Exception as e:
             self.logger.error(f"Failed to refresh tray menu: {e}")
     
-    def start(self):        
+    def start(self):
         if not self.available:
             return False
-        
+
         if self.is_running:
             self.logger.warning("System tray is already running")
             return True
-        
+
         try:
-            idle_icon = self.icons.get("idle")    
+            idle_icon = self.icons.get("idle")
             menu = self._create_menu()
-            
+
             self.icon = pystray.Icon(
                 name="whisper-key",
                 icon=idle_icon,
                 title="Whisper Key",
                 menu=menu
             )
-            
-            self.thread = threading.Thread(target=self._run_tray, daemon=True)
-            self.thread.start()
-            
+
+            self.icon.run_detached()
+
             self.is_running = True
             print("   ✓ System tray icon is running...")
 
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to start system tray: {e}")
             return False
     
-    def _run_tray(self):
-        try:
-            self.icon.run()  # pystray provided loop method
-        except Exception as e:
-            self.logger.error(f"System tray thread error: {e}")
-        finally:
-            self.is_running = False
-            self.logger.debug("Tray icon thread ended")
-    
     def stop(self):
         if not self.is_running:
             return
-        
+
         try:
             self.icon.stop()
-                
-            # Wait for thread to finish to avoid deadlock
-            if self.thread and self.thread.is_alive() and self.thread != threading.current_thread():
-                self.thread.join(timeout=2.0)
-                
             self.is_running = False
-            
+
         except Exception as e:
             self.logger.error(f"Error stopping system tray: {e}")

whisper_key/terminal_ui.py

@@ -0,0 +1,71 @@
+import sys
+
+CYAN = "\x1b[36m"
+BOLD_CYAN = "\x1b[1;36m"
+DIM = "\x1b[2m"
+RESET = "\x1b[0m"
+
+
+def getch():
+    try:
+        import tty
+        import termios
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(fd)
+            ch = sys.stdin.read(1)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        return ch
+    except Exception:
+        line = input()
+        return line[0] if line else '\n'
+
+
+def prompt_choice(title: str, options: list[tuple[str, str]]) -> int:
+    all_texts = [title]
+    for main_text, desc in options:
+        all_texts.append(main_text)
+        if desc:
+            all_texts.append("    " + desc)
+
+    width = max(len(t) for t in all_texts) + 2
+
+    def pad(text):
+        return text + ' ' * (width - len(text))
+
+    def line(text=""):
+        return f"{CYAN}  │{RESET} {pad(text)} {CYAN}│{RESET}"
+
+    def line_dim(text):
+        return f"{CYAN}  │{RESET} {DIM}{pad(text)}{RESET} {CYAN}│{RESET}"
+
+    print()
+    print(f"{CYAN}  ┌{'─' * (width + 2)}┐{RESET}")
+    print(f"{CYAN}  │{RESET} {BOLD_CYAN}{pad(title)}{RESET} {CYAN}│{RESET}")
+
+    for i, (main_text, desc) in enumerate(options, 1):
+        print(line())
+        print(line(f"[{i}] {main_text}"))
+        if desc:
+            print(line_dim("    " + desc))
+
+    print(f"{CYAN}  └{'─' * (width + 2)}┘{RESET}")
+    print()
+    print("  Press a number to choose: ", end="", flush=True)
+
+    valid_choices = {str(i): i for i in range(1, len(options) + 1)}
+
+    while True:
+        try:
+            ch = getch()
+            if ch in valid_choices:
+                print(ch)
+                return valid_choices[ch]
+            if ch in ('\x03', '\x04'):
+                print()
+                return -1
+        except (KeyboardInterrupt, EOFError):
+            print()
+            return -1

whisper_key/utils.py

@@ -33,10 +33,14 @@ def is_installed_package():
     return 'site-packages' in __file__
 
 def get_user_app_data_path():
-    appdata = os.getenv('APPDATA')
-    whisperkey_dir = os.path.join(appdata, 'whisperkey')
-    os.makedirs(whisperkey_dir, exist_ok=True)
-    return whisperkey_dir
+    from .platform import paths
+    whisperkey_dir = paths.get_app_data_path()
+    whisperkey_dir.mkdir(parents=True, exist_ok=True)
+    return str(whisperkey_dir)
+
+def open_file(path):
+    from .platform import paths
+    paths.open_file(path)
 
 def resolve_asset_path(relative_path: str) -> str: