A free, open source, and extensible speech-to-text application that works completely offline.
secure input warning and fallback (#1785)
CJ Paisd001fcd938aa
diff --git a/src-tauri/resources/handy_warning.png b/src-tauri/resources/handy_warning.pngnew file mode 100644index 00000000..55e84e83Binary files /dev/null and b/src-tauri/resources/handy_warning.png differdiff --git a/src-tauri/resources/tray_idle_warning.png b/src-tauri/resources/tray_idle_warning.pngnew file mode 100644index 00000000..7fc1f6cfBinary files /dev/null and b/src-tauri/resources/tray_idle_warning.png differdiff --git a/src-tauri/resources/tray_idle_warning_dark.png b/src-tauri/resources/tray_idle_warning_dark.pngnew file mode 100644index 00000000..6f1619f0Binary files /dev/null and b/src-tauri/resources/tray_idle_warning_dark.png differdiff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex 45e4fdc0..4efc2817 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -179,8 +179,9 @@ pub fn initialize_shortcuts(app: AppHandle) -> Result<(), String> {// Initialize shortcutscrate::shortcut::init_shortcuts(&app);- // Mark as initialized+ // Mark as initialized before reconciling the macOS Secure Input fallback.app.manage(ShortcutsInitialized);+ crate::secure_input::reconcile_fallback(&app);log::info!("Shortcuts initialized successfully");Ok(())diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex b4e83981..0faef85e 100644--- a/src-tauri/src/lib.rs+++ b/src-tauri/src/lib.rs@@ -13,6 +13,7 @@ mod llm_client;mod managers;mod overlay;pub mod portable;+mod secure_input;mod settings;mod shortcut;mod signal_handle;@@ -206,7 +207,7 @@ fn initialize_core_logic(app_handle: &AppHandle) {let initial_theme = tray::get_current_theme(app_handle);// Choose the appropriate initial icon based on theme- let initial_icon_path = tray::get_icon_path(initial_theme, tray::TrayIconState::Idle);+ let initial_icon_path = tray::get_icon_path(initial_theme, tray::TrayIconState::Idle, false);let mut tray_builder = TrayIconBuilder::new().icon(@@ -255,6 +256,10 @@ fn initialize_core_logic(app_handle: &AppHandle) {"settings" => {show_main_window(app);}+ "secure_input_warning" => {+ // Full explanation lives in the settings-window banner+ show_main_window(app);+ }"check_updates" => {let settings = settings::get_settings(app);if settings.update_checks_enabled {@@ -657,6 +662,8 @@ pub fn run(cli_args: CliArgs) {shortcut::get_available_accelerators,shortcut::handy_keys::start_handy_keys_recording,shortcut::handy_keys::stop_handy_keys_recording,+ secure_input::get_secure_input_status,+ secure_input::run_keyboard_diagnostic,trigger_update_check,show_main_window_command,commands::cancel_operation,@@ -911,6 +918,11 @@ pub fn run(cli_args: CliArgs) {initialize_core_logic(&app_handle);+ // Secure Input monitor (macOS): detects stuck secure input that+ // silently blocks keyed shortcuts, warns the user, and activates+ // the Carbon fallback. See secure_input.rs and issue #1578.+ secure_input::init(&app_handle);+// Populate the overlay-enabled cache from initial settings so the// audio path (overlay::emit_levels, called ~24 Hz during recording)// can do a single atomic load instead of reading the Tauri store.diff --git a/src-tauri/src/secure_input.rs b/src-tauri/src/secure_input.rsnew file mode 100644index 00000000..9512c5cd--- /dev/null+++ b/src-tauri/src/secure_input.rs@@ -0,0 +1,660 @@+//! macOS Secure Event Input detection, monitoring, and fallback.+//!+//! When any process enables secure event input (password fields, Terminal's+//! "Secure Keyboard Entry", a stuck `loginwindow`), CGEventTaps stop receiving+//! KeyDown/KeyUp events while FlagsChanged still flows. The handy-keys+//! implementation is tap-based, so keyed shortcuts (e.g. Option+Space) die+//! silently while modifier-only shortcuts keep working. See issue #1578.+//!+//! This module:+//! - polls `IsSecureEventInputEnabled()` and tracks state transitions+//! - looks up the holding process (best effort — Apple documents no reliable+//! API; the IORegistry PID is frequently wrong or absent)+//! - while secure input is sustained, shadow-registers vulnerable *keyed*+//! bindings through the Carbon-backed Tauri global-shortcut path, which is+//! not affected by secure input (modifier-only bindings need no fallback)+//! - dynamically shadows the Cancel binding while recording, so Escape and+//! other keyed cancellation shortcuts remain available under secure input+//! - exposes a count-only keyboard diagnostic for the debug window. Only+//! event *kinds* are counted — key identity is never logged or returned.++use serde::Serialize;+use specta::Type;+use tauri::{AppHandle, Emitter, Manager};++#[derive(Debug, Clone, Serialize, Type)]+pub struct SecureInputStatus {+ /// Secure input is currently enabled (live check)+ pub enabled: bool,+ /// Enabled continuously long enough to be considered stuck (not just a+ /// password field gaining momentary focus)+ pub sustained: bool,+ pub culprit_pid: Option<i32>,+ pub culprit_name: Option<String>,+ /// Carbon fallback registrations are currently active+ pub fallback_active: bool,+ /// Binding ids shadow-registered with identical semantics+ pub covered_bindings: Vec<String>,+ /// Side-specific binding ids widened to match either side while shadowed+ pub degraded_bindings: Vec<String>,+ /// Binding ids that cannot fire at all (e.g. fn+key, registration failure)+ pub uncovered_bindings: Vec<String>,+ /// The user tried to record a shortcut while secure input was active.+ /// Treated as user impact even when every binding is covered, so the+ /// warning banner appears and explains why recording refused.+ pub recorder_blocked: bool,+}++#[derive(Debug, Clone, Serialize, Type)]+pub struct KeyboardDiagnosticReport {+ pub secure_input_enabled: bool,+ pub culprit_pid: Option<i32>,+ pub culprit_name: Option<String>,+ /// Counts only — key identity is deliberately never captured.+ pub key_down: u32,+ pub key_up: u32,+ pub flags_changed: u32,+ pub mouse: u32,+ pub duration_ms: u32,+}++#[tauri::command]+#[specta::specta]+pub fn get_secure_input_status(app: AppHandle) -> SecureInputStatus {+ imp::status(&app)+}++#[tauri::command]+#[specta::specta]+pub async fn run_keyboard_diagnostic(+ duration_secs: Option<u32>,+) -> Result<KeyboardDiagnosticReport, String> {+ imp::run_diagnostic(duration_secs.unwrap_or(10).clamp(3, 30)).await+}++/// True if secure input is enabled right now (live check, macOS only).+pub fn is_enabled_now() -> bool {+ imp::is_enabled()+}++/// Record that a shortcut-recording attempt was refused because secure input+/// is active. Flips the warning state so the banner/tray explain the refusal+/// even when every registered binding is covered by the fallback.+pub fn note_recorder_blocked(app: &AppHandle) {+ imp::note_recorder_blocked(app)+}++/// Register/unregister the dynamic Cancel binding through the Carbon fallback+/// while a recording and sustained Secure Input overlap.+pub fn register_cancel_fallback(app: &AppHandle) {+ imp::register_cancel_fallback(app)+}++pub fn unregister_cancel_fallback(app: &AppHandle) {+ imp::unregister_cancel_fallback(app)+}++/// Rebuild Carbon fallback registrations from the current settings and+/// lifecycle state. This is called after shortcut-related settings change.+pub fn reconcile_fallback(app: &AppHandle) {+ imp::reconcile_fallback(app)+}++/// Managed state + monitor startup. On non-macOS platforms the state exists+/// but the monitor never runs and everything reports disabled.+pub fn init(app: &AppHandle) {+ app.manage(imp::SecureInputState::new());+ imp::start_monitor(app);+}++/// Whether the tray should show the warning badge / menu entry.+///+/// Only when the user is actually impacted: a binding is degraded or dead.+/// When every affected binding is covered transparently by the fallback (or+/// none are affected), the experience is seamless and nothing is shown.+pub fn tray_warning_active(app: &AppHandle) -> bool {+ app.try_state::<imp::SecureInputState>()+ .map(|s| s.warning_active())+ .unwrap_or(false)+}++#[cfg(target_os = "macos")]+mod imp {+ use super::*;+ use crate::settings::{self, KeyboardImplementation, ShortcutBinding};+ use log::{debug, error, info, warn};+ use std::process::Command;+ use std::sync::atomic::{AtomicBool, Ordering};+ use std::sync::Mutex;+ use std::time::{Duration, Instant};++ /// How often the monitor thread polls.+ const POLL_INTERVAL: Duration = Duration::from_secs(1);+ /// Secure input must be held this long before we treat it as stuck.+ /// Momentary activation (a password field gaining focus) is normal.+ const SUSTAIN_THRESHOLD: Duration = Duration::from_secs(3);++ #[link(name = "Carbon", kind = "framework")]+ extern "C" {+ // Carbon HIToolbox; Boolean is an unsigned char+ fn IsSecureEventInputEnabled() -> u8;+ }++ pub fn is_enabled() -> bool {+ unsafe { IsSecureEventInputEnabled() != 0 }+ }++ #[derive(Debug, Clone)]+ struct Culprit {+ pid: i32,+ name: String,+ }++ #[derive(Default)]+ struct FallbackState {+ /// Bindings shadow-registered through the Tauri/Carbon path (possibly+ /// with widened modifiers), kept so deactivation unregisters the+ /// exact strings we registered.+ registered: Vec<ShortcutBinding>,+ /// Shadowed with identical semantics+ covered: Vec<String>,+ /// Shadowed, but side-specific modifiers widened to either side+ degraded: Vec<String>,+ /// Cannot fire at all while secure input is held+ uncovered: Vec<String>,+ }++ pub struct SecureInputState {+ enabled: AtomicBool,+ sustained: AtomicBool,+ enabled_since: Mutex<Option<Instant>>,+ culprit: Mutex<Option<Culprit>>,+ fallback: Mutex<FallbackState>,+ /// Serializes fallback registration changes without requiring the+ /// fallback state lock to be held across global-shortcut plugin calls.+ fallback_operation: Mutex<()>,+ recorder_blocked: AtomicBool,+ cancel_requested: AtomicBool,+ monitor_started: AtomicBool,+ }++ impl SecureInputState {+ pub fn new() -> Self {+ Self {+ enabled: AtomicBool::new(false),+ sustained: AtomicBool::new(false),+ enabled_since: Mutex::new(None),+ culprit: Mutex::new(None),+ fallback: Mutex::new(FallbackState::default()),+ fallback_operation: Mutex::new(()),+ recorder_blocked: AtomicBool::new(false),+ cancel_requested: AtomicBool::new(false),+ monitor_started: AtomicBool::new(false),+ }+ }++ pub fn is_sustained(&self) -> bool {+ self.sustained.load(Ordering::SeqCst)+ }++ /// User-visible impact exists: some binding is degraded or dead, or+ /// the user ran into the blocked shortcut recorder.+ pub fn warning_active(&self) -> bool {+ if self.recorder_blocked.load(Ordering::SeqCst) {+ return true;+ }+ if !self.is_sustained() {+ return false;+ }+ let fallback = self.fallback.lock().unwrap();+ !fallback.degraded.is_empty() || !fallback.uncovered.is_empty()+ }+ }++ /// Best-effort culprit lookup via the IORegistry session property.+ /// Apple documents no reliable API for this; the PID may be missing+ /// (an app quit while holding secure input) or point at the wrong+ /// process (often the responsible parent, or `loginwindow`).+ fn lookup_culprit() -> Option<Culprit> {+ let out = Command::new("ioreg")+ .args(["-l", "-w", "0"])+ .output()+ .ok()?;+ let text = String::from_utf8_lossy(&out.stdout);+ let pid: i32 = text+ .lines()+ .find_map(|l| l.split("\"kCGSSessionSecureInputPID\"=").nth(1))?+ .chars()+ .take_while(|c| c.is_ascii_digit())+ .collect::<String>()+ .parse()+ .ok()?;++ // `ps -o comm=` returns the full executable path; show just the+ // binary name ("Terminal", not ".../Terminal.app/Contents/MacOS/Terminal")+ let name = Command::new("ps")+ .args(["-o", "comm=", "-p", &pid.to_string()])+ .output()+ .ok()+ .and_then(|o| {+ let raw = String::from_utf8_lossy(&o.stdout);+ let trimmed = raw.trim();+ (!trimmed.is_empty())+ .then(|| trimmed.rsplit('/').next().unwrap_or(trimmed).to_string())+ })+ .unwrap_or_else(|| "(process no longer running)".to_string());++ Some(Culprit { pid, name })+ }++ pub fn status(app: &AppHandle) -> SecureInputStatus {+ let enabled = is_enabled();+ let state = app.state::<SecureInputState>();++ // Culprit discovery shells out to ioreg and is intentionally performed+ // only by the monitor (or the blocking diagnostic), never by this+ // synchronous Tauri command.+ let culprit = state.culprit.lock().unwrap().clone();+ let fallback = state.fallback.lock().unwrap();+ SecureInputStatus {+ enabled,+ sustained: state.sustained.load(Ordering::SeqCst),+ culprit_pid: culprit.as_ref().map(|c| c.pid),+ culprit_name: culprit.map(|c| c.name),+ fallback_active: !fallback.registered.is_empty(),+ covered_bindings: fallback.covered.clone(),+ degraded_bindings: fallback.degraded.clone(),+ uncovered_bindings: fallback.uncovered.clone(),+ recorder_blocked: state.recorder_blocked.load(Ordering::SeqCst),+ }+ }++ pub fn note_recorder_blocked(app: &AppHandle) {+ let state = app.state::<SecureInputState>();+ if !state.recorder_blocked.swap(true, Ordering::SeqCst) {+ warn!("SecureInput: shortcut recording attempt blocked — surfacing warning");+ refresh_tray(app);+ emit_status(app);+ }+ }++ fn emit_status(app: &AppHandle) {+ let payload = status(app);+ if let Err(e) = app.emit("secure-input-changed", &payload) {+ error!("Failed to emit secure-input-changed: {e}");+ }+ }++ fn refresh_tray(app: &AppHandle) {+ // Tray may be absent (--no-tray)+ if app.try_state::<tauri::tray::TrayIcon>().is_some() {+ crate::tray::refresh_tray_icon(app);+ }+ }++ pub fn start_monitor(app: &AppHandle) {+ let state = app.state::<SecureInputState>();+ if state.monitor_started.swap(true, Ordering::SeqCst) {+ return;+ }++ let app = app.clone();+ std::thread::spawn(move || {+ info!("secure-input monitor started");+ loop {+ std::thread::sleep(POLL_INTERVAL);+ let state = app.state::<SecureInputState>();+ let now_enabled = is_enabled();+ let was_enabled = state.enabled.swap(now_enabled, Ordering::SeqCst);++ if now_enabled && !was_enabled {+ let culprit = lookup_culprit();+ match &culprit {+ Some(c) => {+ info!("SecureInput ENABLED (held by pid {} '{}')", c.pid, c.name)+ }+ None => info!("SecureInput ENABLED (no visible holder)"),+ }+ *state.enabled_since.lock().unwrap() = Some(Instant::now());+ *state.culprit.lock().unwrap() = culprit;+ }++ if !now_enabled {+ // Clear recorder impact on every disabled sample. A short+ // Secure Input episode can otherwise occur entirely+ // between polls and leave this flag latched indefinitely.+ let was_blocked = state.recorder_blocked.swap(false, Ordering::SeqCst);+ if was_enabled {+ info!("SecureInput DISABLED");+ *state.enabled_since.lock().unwrap() = None;+ *state.culprit.lock().unwrap() = None;+ }++ if state.sustained.swap(false, Ordering::SeqCst) {+ reconcile_fallback(&app);+ } else if was_enabled || was_blocked {+ refresh_tray(&app);+ emit_status(&app);+ }+ continue;+ }++ // Promote to "sustained" after the threshold.+ if !state.sustained.load(Ordering::SeqCst) {+ let held_long_enough = state+ .enabled_since+ .lock()+ .unwrap()+ .map(|t| t.elapsed() >= SUSTAIN_THRESHOLD)+ .unwrap_or(false);+ if held_long_enough {+ warn!(+ "SecureInput held for {}s — keyed shortcuts are blocked; activating fallback",+ SUSTAIN_THRESHOLD.as_secs()+ );+ state.sustained.store(true, Ordering::SeqCst);+ reconcile_fallback(&app);+ }+ }+ }+ });+ }++ fn is_mouse_key(key: &handy_keys::Key) -> bool {+ key.to_string().to_lowercase().starts_with("mouse")+ }++ /// Build the Carbon-registrable equivalent of a keyed hotkey.+ ///+ /// Carbon has no concept of left/right modifiers, so side-specific+ /// modifiers widen to the whole group — returned as `degraded: true` so+ /// the UI can call out the changed matching. The fn key cannot be+ /// expressed at all (`None`).+ fn carbon_equivalent(hotkey: &handy_keys::Hotkey) -> Option<(String, bool)> {+ use handy_keys::Modifiers as M;++ if hotkey.modifiers.contains(M::FN) {+ return None;+ }++ let mut widened = M::empty();+ let mut degraded = false;+ for group in [M::CTRL, M::OPT, M::SHIFT, M::CMD] {+ if hotkey.modifiers.intersects(group) {+ widened |= group;+ if !hotkey.modifiers.contains(group) {+ // Only one side was specified — matching gets wider+ degraded = true;+ }+ }+ }++ let carbon_hotkey = handy_keys::Hotkey::new(widened, hotkey.key).ok()?;+ Some((carbon_hotkey.to_handy_string(), degraded))+ }++ /// Register one vulnerable binding through Carbon. `fallback` is local+ /// reconciliation state, never the mutex-protected shared state.+ fn register_fallback_binding(+ app: &AppHandle,+ id: &str,+ binding: &ShortcutBinding,+ fallback: &mut FallbackState,+ ) -> bool {+ let Ok(hotkey) = binding.current_binding.parse::<handy_keys::Hotkey>() else {+ warn!(+ "SecureInput fallback: '{}' has unparseable binding '{}', skipping",+ id, binding.current_binding+ );+ fallback.uncovered.push(id.to_string());+ return false;+ };++ match &hotkey.key {+ None => {+ debug!(+ "SecureInput fallback: '{}' ('{}') is modifier-only — immune, no shadow needed",+ id, binding.current_binding+ );+ return true;+ }+ Some(k) if is_mouse_key(k) => {+ debug!(+ "SecureInput fallback: '{}' ('{}') is mouse-based — immune, no shadow needed",+ id, binding.current_binding+ );+ return true;+ }+ Some(_) => {}+ }++ let Some((carbon_binding, degraded)) = carbon_equivalent(&hotkey) else {+ warn!(+ "SecureInput fallback: '{}' ('{}') cannot be expressed via Carbon",+ id, binding.current_binding+ );+ fallback.uncovered.push(id.to_string());+ return false;+ };++ let mut shadow = binding.clone();+ shadow.current_binding = carbon_binding;++ match crate::shortcut::tauri_impl::register_shortcut(app, shadow.clone()) {+ Ok(()) => {+ info!(+ "SecureInput fallback: '{}' registered via Carbon as '{}'{}",+ id,+ shadow.current_binding,+ if degraded {+ " (widened to either side)"+ } else {+ ""+ }+ );+ fallback.registered.push(shadow);+ if degraded {+ fallback.degraded.push(id.to_string());+ } else {+ fallback.covered.push(id.to_string());+ }+ }+ Err(e) => {+ warn!(+ "SecureInput fallback: could not cover '{}' ('{}'): {}",+ id, shadow.current_binding, e+ );+ fallback.uncovered.push(id.to_string());+ }+ }++ false+ }++ /// Rebuild the fallback from current state. The operation mutex serializes+ /// reconciliations, while the fallback mutex is released before every+ /// global-shortcut plugin call to avoid lock-order inversion with callbacks.+ pub fn reconcile_fallback(app: &AppHandle) {+ let state = app.state::<SecureInputState>();+ let _operation = state.fallback_operation.lock().unwrap();++ let previous = {+ let mut fallback = state.fallback.lock().unwrap();+ std::mem::take(&mut *fallback)+ };++ if !previous.registered.is_empty() {+ info!(+ "SecureInput fallback reconciling: removing {} Carbon shadow(s)",+ previous.registered.len()+ );+ }+ for binding in previous.registered {+ if let Err(e) = crate::shortcut::tauri_impl::unregister_shortcut(app, binding.clone()) {+ warn!(+ "SecureInput fallback: failed to unregister '{}': {}",+ binding.current_binding, e+ );+ }+ }++ let settings = settings::get_settings(app);+ let eligible = state.is_sustained()+ && app+ .try_state::<crate::commands::ShortcutsInitialized>()+ .is_some()+ && settings.keyboard_implementation == KeyboardImplementation::HandyKeys;++ let mut next = FallbackState::default();+ let mut immune = 0usize;+ if eligible {+ for (id, binding) in &settings.bindings {+ if id == "cancel" && !state.cancel_requested.load(Ordering::SeqCst) {+ continue;+ }+ if id == "transcribe_with_post_process" && !settings.post_process_enabled {+ continue;+ }++ if register_fallback_binding(app, id, binding, &mut next) {+ immune += 1;+ }+ }++ info!(+ "SecureInput fallback active: {} covered, {} degraded, {} uncovered, {} immune (user impact: {})",+ next.covered.len(),+ next.degraded.len(),+ next.uncovered.len(),+ immune,+ !next.degraded.is_empty() || !next.uncovered.is_empty()+ );+ } else if state.is_sustained()+ && app+ .try_state::<crate::commands::ShortcutsInitialized>()+ .is_none()+ {+ debug!("SecureInput fallback deferred until shortcuts are initialized");+ }++ *state.fallback.lock().unwrap() = next;+ drop(_operation);+ refresh_tray(app);+ emit_status(app);+ }++ fn schedule_reconcile(app: &AppHandle) {+ let app = app.clone();+ tauri::async_runtime::spawn(async move {+ reconcile_fallback(&app);+ });+ }++ pub fn register_cancel_fallback(app: &AppHandle) {+ let state = app.state::<SecureInputState>();+ state.cancel_requested.store(true, Ordering::SeqCst);+ schedule_reconcile(app);+ }++ pub fn unregister_cancel_fallback(app: &AppHandle) {+ let state = app.state::<SecureInputState>();+ state.cancel_requested.store(false, Ordering::SeqCst);+ schedule_reconcile(app);+ }++ /// Count-only capture test for the debug window. Opens a short-lived+ /// keyboard listener and tallies event kinds; key identity is never+ /// inspected beyond the mouse/keyboard distinction, and nothing about+ /// individual events is logged or returned.+ pub async fn run_diagnostic(duration_secs: u32) -> Result<KeyboardDiagnosticReport, String> {+ tauri::async_runtime::spawn_blocking(move || {+ let listener = handy_keys::KeyboardListener::new()+ .map_err(|e| format!("Failed to create keyboard listener: {e}"))?;++ let enabled_at_start = is_enabled();+ let start = Instant::now();+ let deadline = start + Duration::from_secs(duration_secs as u64);+ let (mut key_down, mut key_up, mut flags_changed, mut mouse) = (0u32, 0u32, 0u32, 0u32);++ while Instant::now() < deadline {+ match listener.try_recv() {+ Some(event) => match &event.key {+ Some(k) if is_mouse_key(k) => mouse += 1,+ Some(_) if event.is_key_down => key_down += 1,+ Some(_) => key_up += 1,+ None => flags_changed += 1,+ },+ None => std::thread::sleep(Duration::from_millis(10)),+ }+ }++ let enabled = enabled_at_start || is_enabled();+ let culprit = if enabled { lookup_culprit() } else { None };+ info!(+ "keyboard diagnostic: secure_input={} key_down={} key_up={} flags_changed={} mouse={}",+ enabled, key_down, key_up, flags_changed, mouse+ );++ Ok(KeyboardDiagnosticReport {+ secure_input_enabled: enabled,+ culprit_pid: culprit.as_ref().map(|c| c.pid),+ culprit_name: culprit.map(|c| c.name),+ key_down,+ key_up,+ flags_changed,+ mouse,+ duration_ms: start.elapsed().as_millis() as u32,+ })+ })+ .await+ .map_err(|e| format!("Diagnostic task failed: {e}"))?+ }+}++#[cfg(not(target_os = "macos"))]+mod imp {+ use super::*;++ pub struct SecureInputState;++ impl SecureInputState {+ pub fn new() -> Self {+ Self+ }+ pub fn warning_active(&self) -> bool {+ false+ }+ }++ pub fn is_enabled() -> bool {+ false+ }++ pub fn start_monitor(_app: &AppHandle) {}++ pub fn status(_app: &AppHandle) -> SecureInputStatus {+ SecureInputStatus {+ enabled: false,+ sustained: false,+ culprit_pid: None,+ culprit_name: None,+ fallback_active: false,+ covered_bindings: Vec::new(),+ degraded_bindings: Vec::new(),+ uncovered_bindings: Vec::new(),+ recorder_blocked: false,+ }+ }++ pub fn note_recorder_blocked(_app: &AppHandle) {}++ pub fn register_cancel_fallback(_app: &AppHandle) {}++ pub fn unregister_cancel_fallback(_app: &AppHandle) {}++ pub fn reconcile_fallback(_app: &AppHandle) {}++ pub async fn run_diagnostic(_duration_secs: u32) -> Result<KeyboardDiagnosticReport, String> {+ Err("The keyboard diagnostic is only supported on macOS".to_string())+ }+}diff --git a/src-tauri/src/shortcut/handy_keys.rs b/src-tauri/src/shortcut/handy_keys.rsindex 3153d5e9..4c1d0c1e 100644--- a/src-tauri/src/shortcut/handy_keys.rs+++ b/src-tauri/src/shortcut/handy_keys.rs@@ -527,6 +527,16 @@ pub fn start_handy_keys_recording(app: AppHandle, binding_id: String) -> Result<return Err("handy-keys is not the active keyboard implementation".into());}+ // While Secure Input is active the tap receives no KeyDown/KeyUp, so the+ // recorder would silently capture just the modifier and overwrite the+ // binding with it (issue #1578). Refuse instead; the frontend maps this+ // marker to a localized explanation, and the noted impact makes the+ // warning banner appear with the full story.+ if crate::secure_input::is_enabled_now() {+ crate::secure_input::note_recorder_blocked(&app);+ return Err("secure-input-active".into());+ }+let state = app.try_state::<HandyKeysState>().ok_or("HandyKeysState not initialized")?;diff --git a/src-tauri/src/shortcut/mod.rs b/src-tauri/src/shortcut/mod.rsindex e20edfc2..20817a22 100644--- a/src-tauri/src/shortcut/mod.rs+++ b/src-tauri/src/shortcut/mod.rs@@ -11,7 +11,7 @@mod handler;pub mod handy_keys;-mod tauri_impl;+pub mod tauri_impl;use log::{error, info, warn};use serde::Serialize;@@ -58,6 +58,10 @@ pub fn init_shortcuts(app: &AppHandle) {/// Register the cancel shortcut (called when recording starts)pub fn register_cancel_shortcut(app: &AppHandle) {+ // Track recording lifecycle independently of the current implementation so+ // switching implementations mid-recording cannot leave stale fallback state.+ crate::secure_input::register_cancel_fallback(app);+let settings = get_settings(app);match settings.keyboard_implementation {KeyboardImplementation::Tauri => tauri_impl::register_cancel_shortcut(app),@@ -67,6 +71,8 @@ pub fn register_cancel_shortcut(app: &AppHandle) {/// Unregister the cancel shortcut (called when recording stops)pub fn unregister_cancel_shortcut(app: &AppHandle) {+ crate::secure_input::unregister_cancel_fallback(app);+let settings = get_settings(app);match settings.keyboard_implementation {KeyboardImplementation::Tauri => tauri_impl::unregister_cancel_shortcut(app),@@ -151,6 +157,7 @@ pub fn change_binding(b.current_binding = binding;settings.bindings.insert(id.clone(), b.clone());settings::write_settings(&app, settings);+ crate::secure_input::reconcile_fallback(&app);return Ok(BindingResponse {success: true,binding: Some(b.clone()),@@ -190,8 +197,9 @@ pub fn change_binding(// Update the binding in the settingssettings.bindings.insert(id, updated_binding.clone());- // Save the settings+ // Save the settings and synchronize any active Secure Input shadows.settings::write_settings(&app, settings);+ crate::secure_input::reconcile_fallback(&app);// Return the updated bindingOk(BindingResponse {@@ -282,9 +290,16 @@ pub fn change_keyboard_implementation_setting(settings.keyboard_implementation = new_impl;settings::write_settings(&app, settings);+ // Carbon fallback registrations use the Tauri plugin. Remove them before+ // registering the full Tauri implementation to avoid duplicate conflicts.+ if new_impl == KeyboardImplementation::Tauri {+ crate::secure_input::reconcile_fallback(&app);+ }+// Initialize new implementation if needed (HandyKeys needs state)if new_impl == KeyboardImplementation::HandyKeys && initialize_handy_keys_with_rollback(&app)? {- // Shortcuts already registered during init+ // Shortcuts already registered during init.+ crate::secure_input::reconcile_fallback(&app);return Ok(ImplementationChangeResult {success: true,reset_bindings: vec![],@@ -293,6 +308,7 @@ pub fn change_keyboard_implementation_setting(// Register all shortcuts with new implementation, resetting invalid oneslet reset_bindings = register_all_shortcuts_for_implementation(&app, new_impl);+ crate::secure_input::reconcile_fallback(&app);// Emit event to notify frontend of the changelet _ = app.emit(@@ -454,6 +470,7 @@ fn initialize_handy_keys_with_rollback(app: &AppHandle) -> Result<bool, String>let mut settings = settings::get_settings(app);settings.keyboard_implementation = KeyboardImplementation::Tauri;settings::write_settings(app, settings);+ crate::secure_input::reconcile_fallback(app);tauri_impl::init_shortcuts(app);return Err(format!("Failed to initialize HandyKeys: {}. Reverted to Tauri.",@@ -933,6 +950,7 @@ pub fn change_post_process_enabled_setting(app: AppHandle, enabled: bool) -> Res}}+ crate::secure_input::reconcile_fallback(&app);Ok(())}diff --git a/src-tauri/src/shortcut/tauri_impl.rs b/src-tauri/src/shortcut/tauri_impl.rsindex c12da722..6e19c03c 100644--- a/src-tauri/src/shortcut/tauri_impl.rs+++ b/src-tauri/src/shortcut/tauri_impl.rs@@ -3,7 +3,7 @@//! This module provides shortcut functionality using Tauri's built-in//! global-shortcut plugin.-use log::{error, warn};+use log::{debug, error, warn};use tauri::AppHandle;use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};@@ -108,6 +108,13 @@ pub fn register_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<()if scut == &shortcut {let shortcut_string = scut.into_string();let is_pressed = event.state == ShortcutState::Pressed;+ // Mirrors the handy-keys event log line; the distinct prefix+ // makes it possible to tell which backend fired a shortcut+ // (e.g. when diagnosing the Secure Input fallback)+ debug!(+ "tauri global-shortcut event: binding={}, shortcut={}, state={:?}",+ binding_id_for_closure, shortcut_string, event.state+ );handle_shortcut_event(app_handle,&binding_id_for_closure,diff --git a/src-tauri/src/tray.rs b/src-tauri/src/tray.rsindex 4751c35c..e4e2c564 100644--- a/src-tauri/src/tray.rs+++ b/src-tauri/src/tray.rs@@ -93,8 +93,21 @@ fn windows_taskbar_theme() -> Option<AppTheme> {})}-/// Gets the appropriate icon path for the given theme and state-pub fn get_icon_path(theme: AppTheme, state: TrayIconState) -> &'static str {+/// Gets the appropriate icon path for the given theme and state.+///+/// `warning` overlays a badge on the idle icon while keyboard shortcuts are+/// blocked (macOS Secure Input); recording/transcribing states keep their+/// normal icons so in-flight activity stays recognizable.+pub fn get_icon_path(theme: AppTheme, state: TrayIconState, warning: bool) -> &'static str {+ if warning && state == TrayIconState::Idle {+ return match theme {+ AppTheme::Dark => "resources/tray_idle_warning.png",+ AppTheme::Light => "resources/tray_idle_warning_dark.png",+ // Linux never sets the warning flag (Secure Input is macOS-only),+ // but fall back to the normal icon just in case.+ AppTheme::Colored => "resources/handy.png",+ };+ }match (theme, state) {// Dark theme uses light icons(AppTheme::Dark, TrayIconState::Idle) => "resources/tray_idle.png",@@ -118,7 +131,8 @@ pub fn change_tray_icon(app: &AppHandle, icon: TrayIconState) {// Store current stateapp.state::<CurrentTrayIconState>().set(icon);- let icon_path = get_icon_path(theme, icon);+ let warning = crate::secure_input::tray_warning_active(app);+ let icon_path = get_icon_path(theme, icon, warning);let icon_started = std::time::Instant::now();if let Err(err) = load_tray_icon(@@ -174,6 +188,20 @@ pub fn update_tray_menu(app: &AppHandle, locale: Option<&str>) {let locale = locale.unwrap_or(&settings.app_language);let strings = get_tray_translations(Some(locale.to_string()));+ // Secure Input warning entry (macOS): clicking opens the settings window+ // where the full warning banner explains the situation. Locales that+ // haven't translated the key yet get the English string rather than a+ // blank menu item (build.rs emits "" for missing keys).+ let secure_input_warning = crate::secure_input::tray_warning_active(app).then(|| {+ let label = if strings.secure_input_warning.is_empty() {+ get_tray_translations(Some("en".to_string())).secure_input_warning+ } else {+ strings.secure_input_warning.clone()+ };+ MenuItem::with_id(app, "secure_input_warning", &label, true, None::<&str>)+ .expect("failed to create secure input warning item")+ });+// Platform-specific accelerators#[cfg(target_os = "macos")]let (settings_accelerator, quit_accelerator) = (Some("Cmd+,"), Some("Cmd+Q"));@@ -292,10 +320,19 @@ pub fn update_tray_menu(app: &AppHandle, locale: Option<&str>) {.expect("failed to create menu"),};+ // Both layouts start with [version, separator, ...]; slot the warning in+ // right below the version line so it's the first actionable thing seen.+ let mut tooltip = version_label;+ if let Some(warning_item) = secure_input_warning {+ let _ = menu.insert(&warning_item, 2);+ let _ = menu.insert(&separator(), 3);+ tooltip = format!("{} — {}", tooltip, warning_item.text().unwrap_or_default());+ }+let tray = app.state::<TrayIcon>();let _ = tray.set_menu(Some(menu));let _ = tray.set_icon_as_template(true);- let _ = tray.set_tooltip(Some(version_label));+ let _ = tray.set_tooltip(Some(tooltip));}fn last_transcript_text(entry: &HistoryEntry) -> &str {diff --git a/src/App.css b/src/App.cssindex 650b809b..de315044 100644--- a/src/App.css+++ b/src/App.css@@ -11,6 +11,8 @@--color-logo-stroke: var(--color-logo-stroke);--color-text-stroke: var(--color-text-stroke);--color-mid-gray: var(--color-mid-gray);+ --color-warning: var(--color-warning);+ --color-error: var(--color-error);}:root {@@ -71,6 +73,8 @@--color-background: var(--light-color-background);--color-logo-primary: var(--light-color-logo-primary);--color-logo-stroke: var(--light-color-logo-stroke);+ --color-warning: var(--light-color-warning);+ --color-error: var(--light-color-error);}:root[data-theme="dark"] {@@ -78,6 +82,8 @@--color-background: var(--dark-color-background);--color-logo-primary: var(--dark-color-logo-primary);--color-logo-stroke: var(--dark-color-logo-stroke);+ --color-warning: var(--dark-color-warning);+ --color-error: var(--dark-color-error);}/* macOS - tint native overlay scrollbar thumb */diff --git a/src/App.tsx b/src/App.tsxindex d3b05771..449245a4 100644--- a/src/App.tsx+++ b/src/App.tsx@@ -10,6 +10,7 @@ import {import { ModelStateEvent, RecordingErrorEvent } from "./lib/types/events";import "./App.css";import AccessibilityPermissions from "./components/AccessibilityPermissions";+import SecureInputWarning from "./components/SecureInputWarning";import Footer from "./components/footer";import Onboarding, { AccessibilityOnboarding } from "./components/onboarding";import { Sidebar, SidebarSection, SECTIONS_CONFIG } from "./components/Sidebar";@@ -264,6 +265,8 @@ function App() {"bg-background border border-mid-gray/20 rounded-lg shadow-lg px-4 py-3 flex items-center gap-3 text-sm",title: "font-medium",description: "text-mid-gray",+ actionButton:+ "px-2 py-1 text-xs font-medium rounded-lg border bg-mid-gray/10 border-mid-gray/20 hover:bg-background-ui/30 hover:border-logo-primary cursor-pointer whitespace-nowrap",},}}/>@@ -302,6 +305,7 @@ function App() {<div className="flex-1 overflow-y-auto"><div className="flex flex-col items-center p-4 gap-4"><AccessibilityPermissions />+ <SecureInputWarning />{renderSettingsContent(currentSection)}</div></div>diff --git a/src/bindings.ts b/src/bindings.tsindex f31c730a..3447eea7 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -468,6 +468,17 @@ async stopHandyKeysRecording() : Promise<Result<null, string>> {else return { status: "error", error: e as any };}},+async getSecureInputStatus() : Promise<SecureInputStatus> {+ return await TAURI_INVOKE("get_secure_input_status");+},+async runKeyboardDiagnostic(durationSecs: number | null) : Promise<Result<KeyboardDiagnosticReport, string>> {+ try {+ return { status: "ok", data: await TAURI_INVOKE("run_keyboard_diagnostic", { durationSecs }) };+} catch (e) {+ if(e instanceof Error) throw e;+ else return { status: "error", error: e as any };+}+},async triggerUpdateCheck() : Promise<Result<null, string>> {try {return { status: "ok", data: await TAURI_INVOKE("trigger_update_check") };@@ -936,6 +947,11 @@ export type ImplementationChangeResult = { success: boolean;* List of binding IDs that were reset to defaults due to incompatibility*/reset_bindings: string[] }+export type KeyboardDiagnosticReport = { secure_input_enabled: boolean; culprit_pid: number | null; culprit_name: string | null;+/**+ * Counts only — key identity is deliberately never captured.+ */+key_down: number; key_up: number; flags_changed: number; mouse: number; duration_ms: number }export type KeyboardImplementation = "tauri" | "handy_keys"export type LLMPrompt = { id: string; name: string; prompt: string }export type LogLevel = "trace" | "debug" | "info" | "warn" | "error"@@ -981,6 +997,38 @@ export type PermissionAccess = "allowed" | "denied" | "unknown"export type PostProcessProvider = { id: string; label: string; base_url: string; allow_base_url_edit?: boolean; models_endpoint?: string | null; supports_structured_output?: boolean }export type RecordingRetentionPeriod = "never" | "preserve_limit" | "days_3" | "weeks_2" | "months_3"export type SecretMap = Partial<{ [key in string]: string }>+export type SecureInputStatus = {+/**+ * Secure input is currently enabled (live check)+ */+enabled: boolean;+/**+ * Enabled continuously long enough to be considered stuck (not just a+ * password field gaining momentary focus)+ */+sustained: boolean; culprit_pid: number | null; culprit_name: string | null;+/**+ * Carbon fallback registrations are currently active+ */+fallback_active: boolean;+/**+ * Binding ids shadow-registered with identical semantics+ */+covered_bindings: string[];+/**+ * Side-specific binding ids widened to match either side while shadowed+ */+degraded_bindings: string[];+/**+ * Binding ids that cannot fire at all (e.g. fn+key, registration failure)+ */+uncovered_bindings: string[];+/**+ * The user tried to record a shortcut while secure input was active.+ * Treated as user impact even when every binding is covered, so the+ * warning banner appears and explains why recording refused.+ */+recorder_blocked: boolean }export type ShortcutBinding = { id: string; name: string; description: string; default_binding: string; current_binding: string }export type SoundTheme = "marimba" | "pop" | "custom"/**diff --git a/src/components/SecureInputWarning.tsx b/src/components/SecureInputWarning.tsxnew file mode 100644index 00000000..e064f7c1--- /dev/null+++ b/src/components/SecureInputWarning.tsx@@ -0,0 +1,121 @@+import { useCallback, useEffect, useState } from "react";+import { useTranslation } from "react-i18next";+import { listen } from "@tauri-apps/api/event";+import { openUrl } from "@tauri-apps/plugin-opener";+import { ExternalLink, TriangleAlert, X } from "lucide-react";+import { commands, type SecureInputStatus } from "@/bindings";++// Detailed remediation steps live in the docs rather than in the banner+export const SECURE_INPUT_HELP_URL =+ "https://handy.computer/docs/troubleshooting#shortcuts-stopped-working-on-macos-secure-input";++/**+ * Compact warning banner shown while macOS Secure Input is stuck on.+ *+ * Secure Input (password fields, Terminal's "Secure Keyboard Entry", a stuck+ * loginwindow) blocks key events from reaching Handy's keyboard listener, so+ * keyed shortcuts silently stop firing (issue #1578). The backend monitor+ * emits `secure-input-changed` on state transitions; `sustained` filters out+ * the normal momentary activation from focusing a password field.+ */+const SecureInputWarning: React.FC = () => {+ const { t } = useTranslation();+ const [status, setStatus] = useState<SecureInputStatus | null>(null);+ const [dismissed, setDismissed] = useState(false);++ const refresh = useCallback(async () => {+ try {+ setStatus(await commands.getSecureInputStatus());+ } catch (e) {+ console.warn("Failed to fetch secure input status:", e);+ }+ }, []);++ useEffect(() => {+ refresh();+ const unlisten = listen<SecureInputStatus>(+ "secure-input-changed",+ (event) => setStatus(event.payload),+ );+ return () => {+ unlisten.then((fn) => fn());+ };+ }, [refresh]);++ // Only warn when the user is actually impacted: a binding is degraded+ // (side-specific matching widened) or dead (e.g. fn+key), or they ran into+ // the blocked shortcut recorder. When the fallback covers everything+ // transparently — and nothing else surfaced — stay silent; the backend+ // still logs.+ const impacted =+ status !== null &&+ ((status.sustained &&+ (status.degraded_bindings.length > 0 ||+ status.uncovered_bindings.length > 0)) ||+ status.recorder_blocked);++ // A dismissal lasts for the current episode only: once the condition+ // clears, the next occurrence warns again. The tray badge is the+ // persistent indicator and is not dismissible.+ useEffect(() => {+ if (!impacted) {+ setDismissed(false);+ }+ }, [impacted]);++ if (!impacted || dismissed) {+ return null;+ }++ const affectedCount = new Set([+ ...status.uncovered_bindings,+ ...status.degraded_bindings,+ ]).size;+ const countSuffix = affectedCount === 1 ? "one" : "other";+ const message =+ affectedCount > 0+ ? status.culprit_name !== null+ ? t(`secureInput.blockedWithCulprit_${countSuffix}`, {+ name: status.culprit_name,+ count: affectedCount,+ })+ : t(`secureInput.blockedNoCulprit_${countSuffix}`, {+ count: affectedCount,+ })+ : status.culprit_name !== null+ ? t("secureInput.recorderBlockedWithCulprit", {+ name: status.culprit_name,+ })+ : t("secureInput.recorderBlockedNoCulprit");++ return (+ <div className="w-full rounded-lg border border-warning/40 bg-warning/10 px-3 py-2.5">+ <div className="flex items-center gap-3">+ <TriangleAlert className="h-5 w-5 shrink-0 text-warning" />+ <p className="min-w-0 flex-1 text-sm font-medium leading-5">+ {message}+ </p>+ <div className="flex shrink-0 items-center gap-1">+ <button+ onClick={() => openUrl(SECURE_INPUT_HELP_URL)}+ className="cursor-pointer whitespace-nowrap rounded px-2 py-1.5 text-sm font-medium text-text hover:text-warning focus:outline-none focus:ring-1 focus:ring-warning"+ >+ <span className="flex items-center gap-1 border-b border-current leading-4">+ {t("secureInput.learnMore")}+ <ExternalLink className="h-3.5 w-3.5" />+ </span>+ </button>+ <button+ onClick={() => setDismissed(true)}+ aria-label={t("secureInput.dismiss")}+ className="cursor-pointer rounded p-1.5 text-mid-gray hover:bg-warning/15 hover:text-warning focus:outline-none focus:ring-1 focus:ring-warning"+ >+ <X className="h-4 w-4" />+ </button>+ </div>+ </div>+ </div>+ );+};++export default SecureInputWarning;diff --git a/src/components/settings/HandyKeysShortcutInput.tsx b/src/components/settings/HandyKeysShortcutInput.tsxindex d5f5ed03..5a1b4b58 100644--- a/src/components/settings/HandyKeysShortcutInput.tsx+++ b/src/components/settings/HandyKeysShortcutInput.tsx@@ -8,6 +8,8 @@ import { useSettings } from "../../hooks/useSettings";import { useOsType } from "../../hooks/useOsType";import { commands } from "@/bindings";import { toast } from "sonner";+import { openUrl } from "@tauri-apps/plugin-opener";+import { SECURE_INPUT_HELP_URL } from "../SecureInputWarning";interface HandyKeysShortcutInputProps {descriptionMode?: "inline" | "tooltip";@@ -39,6 +41,13 @@ export const HandyKeysShortcutInput: React.FC<HandyKeysShortcutInputProps> = ({const unlistenRef = useRef<(() => void) | null>(null);// Use a ref to track currentKeys for the event handler (avoids stale closure)const currentKeysRef = useRef<string>("");+ // Track keyed vs modifier-only captures separately so a combo commits only+ // on its key's release and a modifier-only shortcut only once every+ // modifier is released. Committing on the *first* release (the old+ // behavior) silently saved just the modifier whenever the key event never+ // arrived — e.g. while macOS Secure Input is active (issue #1578).+ const keyedShortcutRef = useRef<string>("");+ const modifierOnlyShortcutRef = useRef<string>("");const osType = useOsType();const bindings = getSetting("bindings") || {};@@ -69,6 +78,8 @@ export const HandyKeysShortcutInput: React.FC<HandyKeysShortcutInputProps> = ({setIsRecording(false);setCurrentKeys("");currentKeysRef.current = "";+ keyedShortcutRef.current = "";+ modifierOnlyShortcutRef.current = "";setOriginalBinding("");}, [isRecording, originalBinding, shortcutId, updateBinding, t]);@@ -80,51 +91,78 @@ export const HandyKeysShortcutInput: React.FC<HandyKeysShortcutInputProps> = ({const setupListener = async () => {// Listen for key events from backend+ const commitAndStop = async (keysToCommit: string) => {+ try {+ await updateBinding(shortcutId, keysToCommit);+ } catch (error) {+ console.error("Failed to change binding:", error);+ toast.error(+ t("settings.general.shortcut.errors.set", {+ error: String(error),+ }),+ );++ // Reset to original binding on error+ if (originalBinding) {+ try {+ await updateBinding(shortcutId, originalBinding);+ } catch (resetError) {+ console.error("Failed to reset binding:", resetError);+ toast.error(t("settings.general.shortcut.errors.reset"));+ }+ }+ }++ // Stop recording+ if (unlistenRef.current) {+ unlistenRef.current();+ unlistenRef.current = null;+ }+ await commands.stopHandyKeysRecording().catch(console.error);+ setIsRecording(false);+ setCurrentKeys("");+ currentKeysRef.current = "";+ keyedShortcutRef.current = "";+ modifierOnlyShortcutRef.current = "";+ setOriginalBinding("");+ };+const unlisten = await listen<HandyKeysEvent>("handy-keys-event",async (event) => {if (cleanup) return;- const { hotkey_string, is_key_down } = event.payload;+ const { hotkey_string, is_key_down, key, modifiers } = event.payload;if (is_key_down && hotkey_string) {- // Update both state (for display) and ref (for release handler)+ // Update both state (for display) and refs (for release handler)+ if (key) {+ keyedShortcutRef.current = hotkey_string;+ } else {+ modifierOnlyShortcutRef.current = hotkey_string;+ }currentKeysRef.current = hotkey_string;setCurrentKeys(hotkey_string);- } else if (!is_key_down && currentKeysRef.current) {- // Key released - commit the shortcut using the ref value- const keysToCommit = currentKeysRef.current;- try {- await updateBinding(shortcutId, keysToCommit);- } catch (error) {- console.error("Failed to change binding:", error);- toast.error(- t("settings.general.shortcut.errors.set", {- error: String(error),- }),- );-- // Reset to original binding on error- if (originalBinding) {- try {- await updateBinding(shortcutId, originalBinding);- } catch (resetError) {- console.error("Failed to reset binding:", resetError);- toast.error(t("settings.general.shortcut.errors.reset"));- }- }+ } else if (!is_key_down && key) {+ // The main key was released — commit the keyed combo. The release+ // event's hotkey_string still contains the key, so it works even+ // if the key-down was somehow missed. Never fall back to a+ // modifier-only capture here: that's how bindings used to get+ // silently overwritten with just the modifier (issue #1578).+ const keysToCommit = keyedShortcutRef.current || hotkey_string;+ if (keysToCommit) {+ await commitAndStop(keysToCommit);}-- // Stop recording- if (unlistenRef.current) {- unlistenRef.current();- unlistenRef.current = null;- }- await commands.stopHandyKeysRecording().catch(console.error);- setIsRecording(false);- setCurrentKeys("");- currentKeysRef.current = "";- setOriginalBinding("");+ } else if (+ !is_key_down &&+ !key &&+ modifiers.length === 0 &&+ !keyedShortcutRef.current &&+ modifierOnlyShortcutRef.current+ ) {+ // Every modifier released without a main key ever going down —+ // commit as a modifier-only shortcut+ await commitAndStop(modifierOnlyShortcutRef.current);}},);@@ -176,12 +214,34 @@ export const HandyKeysShortcutInput: React.FC<HandyKeysShortcutInputProps> = ({// Store the original binding to restore if canceledsetOriginalBinding(bindings[shortcutId]?.current_binding || "");- // Start backend recording+ // Start backend recording. The backend refuses while macOS Secure Input+ // is active (the recorder's listener would receive no key events and+ // capture just the modifier) — it also flips the warning banner on, so+ // the toast points at a visible explanation.try {- await commands.startHandyKeysRecording(shortcutId);+ const result = await commands.startHandyKeysRecording(shortcutId);+ if (result.status === "error") {+ if (String(result.error).includes("secure-input-active")) {+ toast.error(t("secureInput.recorderBlocked"), {+ action: {+ label: t("secureInput.learnMore"),+ onClick: () => openUrl(SECURE_INPUT_HELP_URL),+ },+ });+ } else {+ toast.error(+ t("settings.general.shortcut.errors.set", {+ error: String(result.error),+ }),+ );+ }+ return;+ }setIsRecording(true);setCurrentKeys("");currentKeysRef.current = "";+ keyedShortcutRef.current = "";+ modifierOnlyShortcutRef.current = "";} catch (error) {console.error("Failed to start recording:", error);toast.error(diff --git a/src/components/settings/debug/DebugSettings.tsx b/src/components/settings/debug/DebugSettings.tsxindex de6d6297..c3e1b339 100644--- a/src/components/settings/debug/DebugSettings.tsx+++ b/src/components/settings/debug/DebugSettings.tsx@@ -11,6 +11,7 @@ import { SoundPicker } from "../SoundPicker";import { ClamshellMicrophoneSelector } from "../ClamshellMicrophoneSelector";import { UpdateChecksToggle } from "../UpdateChecksToggle";import { WhatsNewPreview } from "./WhatsNewPreview";+import { KeyboardDiagnostic } from "./KeyboardDiagnostic";export const DebugSettings: React.FC = () => {const { t } = useTranslation();@@ -37,6 +38,7 @@ export const DebugSettings: React.FC = () => {<RecordingBuffer descriptionMode="tooltip" grouped={true} /><AlwaysOnMicrophone descriptionMode="tooltip" grouped={true} /><ClamshellMicrophoneSelector descriptionMode="tooltip" grouped={true} />+ <KeyboardDiagnostic /><LiveLogViewer descriptionMode="tooltip" grouped={true} /></SettingsGroup></div>diff --git a/src/components/settings/debug/KeyboardDiagnostic.tsx b/src/components/settings/debug/KeyboardDiagnostic.tsxnew file mode 100644index 00000000..a333359a--- /dev/null+++ b/src/components/settings/debug/KeyboardDiagnostic.tsx@@ -0,0 +1,120 @@+import React, { useState } from "react";+import { useTranslation } from "react-i18next";+import { commands, type KeyboardDiagnosticReport } from "@/bindings";+import { useOsType } from "../../../hooks/useOsType";++/**+ * Count-only keyboard capture test (macOS).+ *+ * Opens a short-lived listener and tallies how many key-down / key-up /+ * modifier / mouse events reach Handy — never *which* keys were pressed.+ * The signature of stuck Secure Input (issue #1578) is modifier events+ * flowing while key-down stays at zero.+ */+export const KeyboardDiagnostic: React.FC = () => {+ const { t } = useTranslation();+ const osType = useOsType();+ const [running, setRunning] = useState(false);+ const [report, setReport] = useState<KeyboardDiagnosticReport | null>(null);+ const [error, setError] = useState<string | null>(null);++ if (osType !== "macos") {+ return null;+ }++ const runDiagnostic = async () => {+ setRunning(true);+ setReport(null);+ setError(null);+ try {+ const result = await commands.runKeyboardDiagnostic(10);+ if (result.status === "ok") {+ setReport(result.data);+ } else {+ setError(result.error);+ }+ } catch (e) {+ setError(String(e));+ } finally {+ setRunning(false);+ }+ };++ const verdict = (r: KeyboardDiagnosticReport): string => {+ if (r.secure_input_enabled && r.key_down === 0) {+ return t("settings.debug.keyboardDiagnostic.verdictBlocked");+ }+ if (!r.secure_input_enabled && r.key_down === 0 && r.flags_changed > 0) {+ return t("settings.debug.keyboardDiagnostic.verdictSuspicious");+ }+ if (r.key_down === 0 && r.flags_changed === 0 && r.mouse === 0) {+ return t("settings.debug.keyboardDiagnostic.verdictNoEvents");+ }+ return t("settings.debug.keyboardDiagnostic.verdictOk");+ };++ const secureInputLine = (r: KeyboardDiagnosticReport): string => {+ const state = r.secure_input_enabled+ ? t("settings.debug.keyboardDiagnostic.enabled")+ : t("settings.debug.keyboardDiagnostic.disabled");+ if (!r.secure_input_enabled) {+ return state;+ }+ const holder =+ r.culprit_name !== null+ ? t("settings.debug.keyboardDiagnostic.holder", {+ name: r.culprit_name,+ pid: r.culprit_pid,+ })+ : t("settings.debug.keyboardDiagnostic.holderUnknown");+ return `${state} — ${holder}`;+ };++ return (+ <div className="p-4 space-y-2">+ <div className="flex justify-between items-center gap-2">+ <div>+ <p className="text-sm font-medium">+ {t("settings.debug.keyboardDiagnostic.title")}+ </p>+ <p className="text-xs text-mid-gray">+ {t("settings.debug.keyboardDiagnostic.description")}+ </p>+ </div>+ <button+ onClick={runDiagnostic}+ disabled={running}+ className="px-2 py-1 text-sm font-semibold bg-mid-gray/10 border border-mid-gray/80 hover:bg-logo-primary/10 rounded cursor-pointer hover:border-logo-primary disabled:opacity-50 disabled:cursor-default whitespace-nowrap"+ >+ {t("settings.debug.keyboardDiagnostic.run")}+ </button>+ </div>+ {running && (+ <p className="text-sm animate-pulse">+ {t("settings.debug.keyboardDiagnostic.running")}+ </p>+ )}+ {error !== null && (+ <p className="text-sm text-red-500">+ {t("settings.debug.keyboardDiagnostic.failed", { error })}+ </p>+ )}+ {report !== null && (+ <div className="text-sm font-mono space-y-1">+ <p>+ {t("settings.debug.keyboardDiagnostic.secureInputLabel")}:{" "}+ {secureInputLine(report)}+ </p>+ <p>+ {t("settings.debug.keyboardDiagnostic.keyDown")}: {report.key_down}{" "}+ · {t("settings.debug.keyboardDiagnostic.keyUp")}: {report.key_up} ·{" "}+ {t("settings.debug.keyboardDiagnostic.flagsChanged")}:{" "}+ {report.flags_changed} ·{" "}+ {t("settings.debug.keyboardDiagnostic.mouse")}: {report.mouse}+ </p>+ <p className="font-sans font-medium">{verdict(report)}</p>+ </div>+ )}+ </div>+ );+};diff --git a/src/components/ui/Button.tsx b/src/components/ui/Button.tsxindex df92fdc9..056cbb49 100644--- a/src/components/ui/Button.tsx+++ b/src/components/ui/Button.tsx@@ -5,6 +5,7 @@ interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {| "primary"| "primary-soft"| "secondary"+ | "warning"| "danger"| "danger-ghost"| "ghost";@@ -28,6 +29,11 @@ export const Button: React.FC<ButtonProps> = ({"text-text bg-logo-primary/20 border-transparent hover:bg-logo-primary/30 focus:ring-1 focus:ring-logo-primary",secondary:"bg-mid-gray/10 border-mid-gray/20 hover:bg-background-ui/30 hover:border-logo-primary focus:outline-none",+ // Secondary's neutral resting look, but hover/focus use the semantic+ // --color-warning token (theme.css) instead of the pink accent — for+ // buttons sitting on warning surfaces like SecureInputWarning+ warning:+ "text-text bg-mid-gray/10 border-mid-gray/20 hover:bg-warning/15 hover:border-warning focus:ring-1 focus:ring-warning",danger:"text-white bg-red-600 border-mid-gray/20 hover:bg-red-700 hover:border-red-700 focus:ring-1 focus:ring-red-500","danger-ghost":diff --git a/src/i18n/locales/ar/translation.json b/src/i18n/locales/ar/translation.jsonindex 801229cf..8c26b0ff 100644--- a/src/i18n/locales/ar/translation.json+++ b/src/i18n/locales/ar/translation.json@@ -6,7 +6,8 @@"unloadModel": "تفريغ النموذج","model": "النموذج","quit": "إنهاء",- "cancel": "إلغاء"+ "cancel": "إلغاء",+ "secureInputWarning": "⚠ الاختصارات محجوبة بواسطة Secure Input"},"sidebar": {"general": "عام",@@ -507,6 +508,26 @@"title": "مخزن التسجيل الإضافي","description": "وقت إضافي (بالمللي ثانية) للاستمرار في التسجيل بعد تحرير المفتاح، لالتقاط الصوت المتبقي. 0 = لا مخزن إضافي."},+ "keyboardDiagnostic": {+ "title": "تشخيص لوحة المفاتيح",+ "description": "يتحقق مما إذا كانت أحداث لوحة المفاتيح تصل إلى Handy. يُسجَّل عدد الأحداث فقط — ولا تُسجَّل أبدًا المفاتيح التي تضغط عليها.",+ "run": "تشغيل تشخيص لمدة 10 ثوانٍ",+ "running": "جارٍ الاستماع… اضغط اختصارك عدة مرات (مثل Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "مُفعَّل",+ "disabled": "مُعطَّل",+ "holder": "يحتجزه {{name}} (pid {{pid}})",+ "holderUnknown": "لا يوجد محتجِز ظاهر",+ "keyDown": "ضغط مفتاح",+ "keyUp": "تحرير مفتاح",+ "flagsChanged": "مفاتيح التعديل",+ "mouse": "الماوس",+ "verdictBlocked": "يحجب Secure Input أحداث المفاتيح — لا يمكن للاختصارات التي تتضمن مفتاحًا عاديًا أن تعمل حتى تُحلّ المشكلة.",+ "verdictSuspicious": "وصلت أحداث مفاتيح التعديل لكن لم يصل أي حدث مفتاح — هناك شيء يمنع المفاتيح رغم أن Secure Input يظهر معطلاً. يُرجى الإبلاغ عن ذلك على GitHub.",+ "verdictOk": "أحداث المفاتيح تصل إلى Handy بشكل طبيعي.",+ "verdictNoEvents": "لم يُسجَّل أي حدث — هل ضغطت أي مفاتيح أثناء الاختبار؟",+ "failed": "فشل التشخيص: {{error}}"+ },"whatsNewPreview": {"title": "معاينة الجديد","description": "افتح أحدث ملاحظات إصدار مضمنة دون وضع علامة عليها كمقروءة",@@ -633,5 +654,16 @@},"whatsNew": {"title": "الجديد في Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "قد يحظر {{name}} اختصارًا واحدًا",+ "blockedWithCulprit_other": "قد يحظر {{name}} {{count}} اختصارات",+ "blockedNoCulprit_one": "يحظر macOS مؤقتًا اختصارًا واحدًا",+ "blockedNoCulprit_other": "يحظر macOS مؤقتًا {{count}} اختصارات",+ "recorderBlockedWithCulprit": "قد يمنع {{name}} تغيير الاختصارات",+ "recorderBlockedNoCulprit": "يمنع macOS مؤقتًا تغيير الاختصارات",+ "learnMore": "كيفية الإصلاح",+ "recorderBlocked": "لا يمكن تسجيل الاختصارات الآن — يحجب Secure Input في macOS أحداث المفاتيح. عالج تحذير Secure Input أولاً.",+ "dismiss": "تجاهل"}}diff --git a/src/i18n/locales/bg/translation.json b/src/i18n/locales/bg/translation.jsonindex 937680ce..d18d5a5b 100644--- a/src/i18n/locales/bg/translation.json+++ b/src/i18n/locales/bg/translation.json@@ -6,7 +6,8 @@"unloadModel": "Разтоварване на модела","model": "Модел","quit": "Изход",- "cancel": "Отказ"+ "cancel": "Отказ",+ "secureInputWarning": "⚠ Бързите клавиши са блокирани от Secure Input"},"sidebar": {"general": "Общи",@@ -528,6 +529,26 @@"title": "Допълнителен буфер на записа","description": "Допълнително време (в милисекунди) за запис след пускане на клавиша, за да се улови краят на аудиото. 0 = без допълнителен буфер."},+ "keyboardDiagnostic": {+ "title": "Диагностика на клавиатурата",+ "description": "Проверява дали клавиатурните събития достигат до Handy. Записва се само броят на събитията — никога кои клавиши натискате.",+ "run": "Стартиране на 10-секундна диагностика",+ "running": "Слушане… натиснете бързия си клавиш няколко пъти (напр. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "включен",+ "disabled": "изключен",+ "holder": "задържан от {{name}} (pid {{pid}})",+ "holderUnknown": "няма видим държател",+ "keyDown": "Натиснат клавиш",+ "keyUp": "Отпуснат клавиш",+ "flagsChanged": "Модификатори",+ "mouse": "Мишка",+ "verdictBlocked": "Secure Input блокира клавишните събития — бързите клавиши с обикновен клавиш не могат да работят, докато това не бъде решено.",+ "verdictSuspicious": "Пристигнаха събития от модификатори, но нито едно клавишно събитие — нещо потиска клавишите, въпреки че Secure Input се отчита като изключен. Моля, съобщете за това в GitHub.",+ "verdictOk": "Клавишните събития достигат до Handy нормално.",+ "verdictNoEvents": "Не са уловени събития — натиснахте ли някакви клавиши по време на теста?",+ "failed": "Диагностиката е неуспешна: {{error}}"+ },"whatsNewPreview": {"title": "Преглед на новостите","description": "Отваря последните включени бележки към изданието, без да ги маркира като видени",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Ново в Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} може да блокира 1 бърз клавиш",+ "blockedWithCulprit_other": "{{name}} може да блокира {{count}} бързи клавиша",+ "blockedNoCulprit_one": "macOS временно блокира 1 бърз клавиш",+ "blockedNoCulprit_other": "macOS временно блокира {{count}} бързи клавиша",+ "recorderBlockedWithCulprit": "{{name}} може да блокира промените на бързите клавиши",+ "recorderBlockedNoCulprit": "macOS временно блокира промените на бързите клавиши",+ "learnMore": "Как да поправите това",+ "recorderBlocked": "В момента не могат да се записват бързи клавиши — Secure Input на macOS блокира клавишните събития. Първо отстранете предупреждението за Secure Input.",+ "dismiss": "Отхвърляне"}}diff --git a/src/i18n/locales/cs/translation.json b/src/i18n/locales/cs/translation.jsonindex ec7017c7..b9873868 100644--- a/src/i18n/locales/cs/translation.json+++ b/src/i18n/locales/cs/translation.json@@ -6,7 +6,8 @@"unloadModel": "Uvolnit model","model": "Model","quit": "Ukončit",- "cancel": "Zrušit"+ "cancel": "Zrušit",+ "secureInputWarning": "⚠ Zkratky blokuje Secure Input"},"sidebar": {"general": "Obecné",@@ -528,6 +529,26 @@"title": "Extra vyrovnávací paměť nahrávání","description": "Extra čas (v milisekundách) pro pokračování nahrávání po uvolnění klávesy, pro zachycení zbývajícího zvuku. 0 = žádná extra vyrovnávací paměť."},+ "keyboardDiagnostic": {+ "title": "Diagnostika klávesnice",+ "description": "Ověří, zda události klávesnice dorazí do Handy. Zaznamenává se pouze počet událostí — nikdy to, které klávesy stisknete.",+ "run": "Spustit 10s diagnostiku",+ "running": "Naslouchání… několikrát stiskněte svou zkratku (např. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "zapnuto",+ "disabled": "vypnuto",+ "holder": "drží ji {{name}} (pid {{pid}})",+ "holderUnknown": "žádný viditelný držitel",+ "keyDown": "Stisk klávesy",+ "keyUp": "Uvolnění klávesy",+ "flagsChanged": "Modifikátory",+ "mouse": "Myš",+ "verdictBlocked": "Secure Input blokuje události kláves — zkratky obsahující běžnou klávesu nemohou fungovat, dokud se to nevyřeší.",+ "verdictSuspicious": "Dorazily události modifikátorů, ale žádné události kláves — něco klávesy potlačuje, přestože Secure Input hlásí, že je vypnutý. Nahlaste to prosím na GitHubu.",+ "verdictOk": "Události kláves dorazí do Handy normálně.",+ "verdictNoEvents": "Nebyly zachyceny žádné události — stiskli jste během testu nějaké klávesy?",+ "failed": "Diagnostika selhala: {{error}}"+ },"whatsNewPreview": {"title": "Náhled novinek","description": "Otevřít nejnovější přibalené poznámky k vydání bez označení jako zobrazené",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Novinky v Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} může blokovat 1 zkratku",+ "blockedWithCulprit_other": "{{name}} může blokovat {{count}} zkratek",+ "blockedNoCulprit_one": "macOS dočasně blokuje 1 zkratku",+ "blockedNoCulprit_other": "macOS dočasně blokuje {{count}} zkratek",+ "recorderBlockedWithCulprit": "{{name}} může blokovat změny zkratek",+ "recorderBlockedNoCulprit": "macOS dočasně blokuje změny zkratek",+ "learnMore": "Jak to vyřešit",+ "recorderBlocked": "Zkratky teď nelze nahrát — Secure Input v macOS blokuje události kláves. Nejprve vyřešte upozornění na Secure Input.",+ "dismiss": "Zavřít"}}diff --git a/src/i18n/locales/da/translation.json b/src/i18n/locales/da/translation.jsonindex 5feb4a9b..3b8da3fb 100644--- a/src/i18n/locales/da/translation.json+++ b/src/i18n/locales/da/translation.json@@ -6,7 +6,8 @@"unloadModel": "Frigør model","model": "Model","quit": "Afslut",- "cancel": "Annuller"+ "cancel": "Annuller",+ "secureInputWarning": "⚠ Genveje blokeret af Secure Input"},"sidebar": {"general": "Generelt",@@ -534,6 +535,26 @@"recordingBuffer": {"title": "Ekstra optagelsesbuffer","description": "Ekstra tid (i millisekunder) til at fortsætte optagelsen, efter du slipper tasten, for at fange efterfølgende lyd. 0 = ingen ekstra buffer."+ },+ "keyboardDiagnostic": {+ "title": "Tastaturdiagnostik",+ "description": "Kontrollerer, om tastaturhændelser når frem til Handy. Kun antallet af hændelser registreres — aldrig hvilke taster du trykker på.",+ "run": "Kør 10 s diagnostik",+ "running": "Lytter… tryk på din genvej et par gange (f.eks. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "aktiveret",+ "disabled": "deaktiveret",+ "holder": "holdes af {{name}} (pid {{pid}})",+ "holderUnknown": "ingen synlig indehaver",+ "keyDown": "Tast ned",+ "keyUp": "Tast op",+ "flagsChanged": "Modifikatorer",+ "mouse": "Mus",+ "verdictBlocked": "Secure Input blokerer tastehændelser — genveje med en almindelig tast kan ikke fungere, før det er løst.",+ "verdictSuspicious": "Der kom modifikatorhændelser, men ingen tastehændelser — noget undertrykker taster, selvom Secure Input rapporteres som deaktiveret. Rapportér det gerne på GitHub.",+ "verdictOk": "Tastehændelser når frem til Handy som normalt.",+ "verdictNoEvents": "Ingen hændelser registreret — trykkede du på nogen taster under testen?",+ "failed": "Diagnostik mislykkedes: {{error}}"}},"about": {@@ -633,5 +654,16 @@"overlay": {"transcribing": "Transskriberer...","processing": "Behandler..."+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} blokerer muligvis 1 genvej",+ "blockedWithCulprit_other": "{{name}} blokerer muligvis {{count}} genveje",+ "blockedNoCulprit_one": "macOS blokerer midlertidigt 1 genvej",+ "blockedNoCulprit_other": "macOS blokerer midlertidigt {{count}} genveje",+ "recorderBlockedWithCulprit": "{{name}} blokerer muligvis ændringer af genveje",+ "recorderBlockedNoCulprit": "macOS blokerer midlertidigt ændringer af genveje",+ "learnMore": "Sådan løser du det",+ "recorderBlocked": "Genveje kan ikke optages lige nu — macOS Secure Input blokerer tastehændelser. Løs advarslen om Secure Input først.",+ "dismiss": "Afvis"}}diff --git a/src/i18n/locales/de/translation.json b/src/i18n/locales/de/translation.jsonindex 094737eb..5e1fcc83 100644--- a/src/i18n/locales/de/translation.json+++ b/src/i18n/locales/de/translation.json@@ -6,7 +6,8 @@"unloadModel": "Modell entladen","model": "Modell","quit": "Beenden",- "cancel": "Abbrechen"+ "cancel": "Abbrechen",+ "secureInputWarning": "⚠ Tastenkürzel durch Secure Input blockiert"},"sidebar": {"general": "Allgemein",@@ -528,6 +529,26 @@"title": "Zusätzlicher Aufnahmepuffer","description": "Zusätzliche Zeit (in Millisekunden), um nach dem Loslassen der Taste weiter aufzunehmen, um nachlaufendes Audio zu erfassen. 0 = kein zusätzlicher Puffer."},+ "keyboardDiagnostic": {+ "title": "Tastatur-Diagnose",+ "description": "Prüft, ob Tastaturereignisse Handy erreichen. Es wird nur die Anzahl der Ereignisse erfasst — niemals, welche Tasten du drückst.",+ "run": "10-Sekunden-Diagnose starten",+ "running": "Lauscht… drücke dein Tastenkürzel ein paar Mal (z. B. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "aktiviert",+ "disabled": "deaktiviert",+ "holder": "gehalten von {{name}} (pid {{pid}})",+ "holderUnknown": "kein sichtbarer Verursacher",+ "keyDown": "Taste gedrückt",+ "keyUp": "Taste losgelassen",+ "flagsChanged": "Modifikatoren",+ "mouse": "Maus",+ "verdictBlocked": "Secure Input blockiert Tastenereignisse — Tastenkürzel mit einer normalen Taste können erst wieder funktionieren, wenn das behoben ist.",+ "verdictSuspicious": "Es kamen Modifikator-Ereignisse an, aber keine Tastenereignisse — irgendetwas unterdrückt Tasten, obwohl Secure Input als deaktiviert gemeldet wird. Bitte melde das auf GitHub.",+ "verdictOk": "Tastenereignisse erreichen Handy normal.",+ "verdictNoEvents": "Keine Ereignisse erfasst — hast du während des Tests Tasten gedrückt?",+ "failed": "Diagnose fehlgeschlagen: {{error}}"+ },"whatsNewPreview": {"title": "Vorschau der Neuerungen","description": "Die neuesten gebündelten Versionshinweise öffnen, ohne sie als gesehen zu markieren",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Neu in Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} blockiert möglicherweise 1 Tastenkürzel",+ "blockedWithCulprit_other": "{{name}} blockiert möglicherweise {{count}} Tastenkürzel",+ "blockedNoCulprit_one": "macOS blockiert vorübergehend 1 Tastenkürzel",+ "blockedNoCulprit_other": "macOS blockiert vorübergehend {{count}} Tastenkürzel",+ "recorderBlockedWithCulprit": "{{name}} blockiert möglicherweise Änderungen an Tastenkürzeln",+ "recorderBlockedNoCulprit": "macOS blockiert vorübergehend Änderungen an Tastenkürzeln",+ "learnMore": "So behebst du das",+ "recorderBlocked": "Tastenkürzel können gerade nicht aufgezeichnet werden — macOS Secure Input blockiert Tastenereignisse. Behebe zuerst die Secure-Input-Warnung.",+ "dismiss": "Ausblenden"}}diff --git a/src/i18n/locales/en/translation.json b/src/i18n/locales/en/translation.jsonindex 33c7321e..1c23046b 100644--- a/src/i18n/locales/en/translation.json+++ b/src/i18n/locales/en/translation.json@@ -6,7 +6,8 @@"unloadModel": "Unload Model","model": "Model","quit": "Quit",- "cancel": "Cancel"+ "cancel": "Cancel",+ "secureInputWarning": "⚠ Shortcuts blocked by Secure Input"},"sidebar": {"general": "General",@@ -534,6 +535,26 @@"recordingBuffer": {"title": "Extra Recording Buffer","description": "Extra time (in milliseconds) to keep recording after you release the key, to capture trailing audio. 0 = no extra buffer."+ },+ "keyboardDiagnostic": {+ "title": "Keyboard Diagnostic",+ "description": "Checks whether keyboard events reach Handy. Only event counts are recorded — never which keys you press.",+ "run": "Run 10s diagnostic",+ "running": "Listening… press your shortcut a few times (e.g. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "enabled",+ "disabled": "disabled",+ "holder": "held by {{name}} (pid {{pid}})",+ "holderUnknown": "no visible holder",+ "keyDown": "Key down",+ "keyUp": "Key up",+ "flagsChanged": "Modifiers",+ "mouse": "Mouse",+ "verdictBlocked": "Secure Input is blocking key events — keyed shortcuts cannot work until it is resolved.",+ "verdictSuspicious": "Modifier events arrived but no key events — something is suppressing keys even though Secure Input reports disabled. Please report this on GitHub.",+ "verdictOk": "Key events are reaching Handy normally.",+ "verdictNoEvents": "No events captured — did you press any keys during the test?",+ "failed": "Diagnostic failed: {{error}}"}},"about": {@@ -633,5 +654,16 @@"overlay": {"transcribing": "Transcribing...","processing": "Processing..."+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} may be blocking 1 shortcut",+ "blockedWithCulprit_other": "{{name}} may be blocking {{count}} shortcuts",+ "blockedNoCulprit_one": "macOS is temporarily blocking 1 shortcut",+ "blockedNoCulprit_other": "macOS is temporarily blocking {{count}} shortcuts",+ "recorderBlockedWithCulprit": "{{name}} may be blocking shortcut changes",+ "recorderBlockedNoCulprit": "macOS is temporarily blocking shortcut changes",+ "learnMore": "How to fix",+ "recorderBlocked": "Can't record shortcuts right now — macOS Secure Input is blocking key events. Resolve the Secure Input warning first.",+ "dismiss": "Dismiss"}}diff --git a/src/i18n/locales/es/translation.json b/src/i18n/locales/es/translation.jsonindex 3efacbdd..a14f33fc 100644--- a/src/i18n/locales/es/translation.json+++ b/src/i18n/locales/es/translation.json@@ -6,7 +6,8 @@"unloadModel": "Descargar modelo","model": "Modelo","quit": "Salir",- "cancel": "Cancelar"+ "cancel": "Cancelar",+ "secureInputWarning": "⚠ Atajos bloqueados por Secure Input"},"sidebar": {"general": "General",@@ -528,6 +529,26 @@"title": "Búfer de grabación adicional","description": "Tiempo adicional (en milisegundos) para seguir grabando después de soltar la tecla, para capturar el audio restante. 0 = sin búfer adicional."},+ "keyboardDiagnostic": {+ "title": "Diagnóstico del teclado",+ "description": "Comprueba si los eventos de teclado llegan a Handy. Solo se registra el número de eventos, nunca qué teclas pulsas.",+ "run": "Ejecutar diagnóstico de 10 s",+ "running": "Escuchando… pulsa tu atajo varias veces (p. ej. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "activado",+ "disabled": "desactivado",+ "holder": "retenido por {{name}} (pid {{pid}})",+ "holderUnknown": "sin responsable visible",+ "keyDown": "Tecla pulsada",+ "keyUp": "Tecla soltada",+ "flagsChanged": "Modificadores",+ "mouse": "Ratón",+ "verdictBlocked": "Secure Input está bloqueando los eventos de teclado: los atajos que incluyen una tecla normal no pueden funcionar hasta que se resuelva.",+ "verdictSuspicious": "Llegaron eventos de modificadores, pero ningún evento de tecla: algo está suprimiendo las teclas aunque Secure Input aparezca como desactivado. Por favor, repórtalo en GitHub.",+ "verdictOk": "Los eventos de teclado llegan a Handy con normalidad.",+ "verdictNoEvents": "No se capturó ningún evento: ¿pulsaste alguna tecla durante la prueba?",+ "failed": "El diagnóstico falló: {{error}}"+ },"whatsNewPreview": {"title": "Vista previa de novedades","description": "Abrir la nota de la versión incluida más reciente sin marcarla como vista",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Nuevo en Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} puede estar bloqueando 1 atajo",+ "blockedWithCulprit_other": "{{name}} puede estar bloqueando {{count}} atajos",+ "blockedNoCulprit_one": "macOS está bloqueando temporalmente 1 atajo",+ "blockedNoCulprit_other": "macOS está bloqueando temporalmente {{count}} atajos",+ "recorderBlockedWithCulprit": "{{name}} puede estar bloqueando los cambios de atajos",+ "recorderBlockedNoCulprit": "macOS está bloqueando temporalmente los cambios de atajos",+ "learnMore": "Cómo solucionarlo",+ "recorderBlocked": "Ahora mismo no se pueden grabar atajos: Secure Input de macOS está bloqueando los eventos de teclado. Resuelve primero el aviso de Secure Input.",+ "dismiss": "Descartar"}}diff --git a/src/i18n/locales/fr/translation.json b/src/i18n/locales/fr/translation.jsonindex 9cce8c47..842b076c 100644--- a/src/i18n/locales/fr/translation.json+++ b/src/i18n/locales/fr/translation.json@@ -6,7 +6,8 @@"unloadModel": "Décharger le modèle","model": "Modèle","quit": "Quitter",- "cancel": "Annuler"+ "cancel": "Annuler",+ "secureInputWarning": "⚠ Raccourcis bloqués par Secure Input"},"sidebar": {"general": "Général",@@ -528,6 +529,26 @@"title": "Tampon d'enregistrement supplémentaire","description": "Temps supplémentaire (en millisecondes) pour continuer l'enregistrement après avoir relâché la touche, pour capturer l'audio restant. 0 = pas de tampon supplémentaire."},+ "keyboardDiagnostic": {+ "title": "Diagnostic du clavier",+ "description": "Vérifie si les événements clavier atteignent Handy. Seul le nombre d'événements est enregistré, jamais les touches sur lesquelles vous appuyez.",+ "run": "Lancer un diagnostic de 10 s",+ "running": "Écoute en cours… appuyez plusieurs fois sur votre raccourci (par ex. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "activé",+ "disabled": "désactivé",+ "holder": "détenu par {{name}} (pid {{pid}})",+ "holderUnknown": "aucun détenteur visible",+ "keyDown": "Touche enfoncée",+ "keyUp": "Touche relâchée",+ "flagsChanged": "Modificateurs",+ "mouse": "Souris",+ "verdictBlocked": "Secure Input bloque les événements clavier : les raccourcis contenant une touche normale ne peuvent pas fonctionner tant que ce n'est pas résolu.",+ "verdictSuspicious": "Des événements de modificateurs sont arrivés, mais aucun événement de touche : quelque chose supprime les touches alors que Secure Input est signalé comme désactivé. Merci de le signaler sur GitHub.",+ "verdictOk": "Les événements clavier atteignent Handy normalement.",+ "verdictNoEvents": "Aucun événement capturé : avez-vous appuyé sur des touches pendant le test ?",+ "failed": "Échec du diagnostic : {{error}}"+ },"whatsNewPreview": {"title": "Aperçu des nouveautés","description": "Ouvrir la dernière note de version intégrée sans la marquer comme vue",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Nouveautés de Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} bloque peut-être 1 raccourci",+ "blockedWithCulprit_other": "{{name}} bloque peut-être {{count}} raccourcis",+ "blockedNoCulprit_one": "macOS bloque temporairement 1 raccourci",+ "blockedNoCulprit_other": "macOS bloque temporairement {{count}} raccourcis",+ "recorderBlockedWithCulprit": "{{name}} bloque peut-être la modification des raccourcis",+ "recorderBlockedNoCulprit": "macOS bloque temporairement la modification des raccourcis",+ "learnMore": "Comment résoudre ce problème",+ "recorderBlocked": "Impossible d'enregistrer un raccourci pour le moment : Secure Input de macOS bloque les événements clavier. Résolvez d'abord l'avertissement Secure Input.",+ "dismiss": "Ignorer"}}diff --git a/src/i18n/locales/he/translation.json b/src/i18n/locales/he/translation.jsonindex 677ee35f..2d2e368c 100644--- a/src/i18n/locales/he/translation.json+++ b/src/i18n/locales/he/translation.json@@ -6,7 +6,8 @@"unloadModel": "פרוק מודל","model": "מודל","quit": "יציאה",- "cancel": "ביטול"+ "cancel": "ביטול",+ "secureInputWarning": "⚠ קיצורי המקשים חסומים על ידי Secure Input"},"sidebar": {"general": "כללי",@@ -528,6 +529,26 @@"title": "באפר הקלטה נוסף","description": "זמן נוסף (במילישניות) להמשך הקלטה אחרי שחרור המקש, כדי ללכוד סוף דיבור. 0 = בלי באפר נוסף."},+ "keyboardDiagnostic": {+ "title": "אבחון מקלדת",+ "description": "בודק אם אירועי מקלדת מגיעים ל-Handy. נרשם רק מספר האירועים — לעולם לא אילו מקשים הקשת.",+ "run": "הרצת אבחון של 10 שניות",+ "running": "מאזין… הקש על קיצור המקשים שלך כמה פעמים (למשל Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "מופעל",+ "disabled": "מושבת",+ "holder": "מוחזק על ידי {{name}} (pid {{pid}})",+ "holderUnknown": "אין מחזיק גלוי",+ "keyDown": "לחיצת מקש",+ "keyUp": "שחרור מקש",+ "flagsChanged": "מקשי החלפה",+ "mouse": "עכבר",+ "verdictBlocked": "Secure Input חוסם אירועי מקשים — קיצורים הכוללים מקש רגיל לא יוכלו לפעול עד שהבעיה תיפתר.",+ "verdictSuspicious": "הגיעו אירועים של מקשי החלפה אך לא אירועי מקשים — משהו מדכא מקשים למרות ש-Secure Input מדווח כמושבת. אנא דווח על כך ב-GitHub.",+ "verdictOk": "אירועי מקשים מגיעים ל-Handy כרגיל.",+ "verdictNoEvents": "לא נקלטו אירועים — האם הקשת על מקשים במהלך הבדיקה?",+ "failed": "האבחון נכשל: {{error}}"+ },"whatsNewPreview": {"title": "תצוגה מקדימה של מה חדש","description": "פתח את הערת הגרסה המצורפת האחרונה בלי לסמן אותה כנצפתה",@@ -633,5 +654,16 @@},"whatsNew": {"title": "חדש ב-Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "ייתכן ש-{{name}} חוסם קיצור דרך אחד",+ "blockedWithCulprit_other": "ייתכן ש-{{name}} חוסם {{count}} קיצורי דרך",+ "blockedNoCulprit_one": "macOS חוסם זמנית קיצור דרך אחד",+ "blockedNoCulprit_other": "macOS חוסם זמנית {{count}} קיצורי דרך",+ "recorderBlockedWithCulprit": "ייתכן ש-{{name}} חוסם שינויים בקיצורי דרך",+ "recorderBlockedNoCulprit": "macOS חוסם זמנית שינויים בקיצורי דרך",+ "learnMore": "איך לתקן את זה",+ "recorderBlocked": "לא ניתן להקליט קיצורים כרגע — Secure Input של macOS חוסם אירועי מקשים. פתור תחילה את אזהרת Secure Input.",+ "dismiss": "התעלם"}}diff --git a/src/i18n/locales/hi/translation.json b/src/i18n/locales/hi/translation.jsonindex 775392b9..b63c058e 100644--- a/src/i18n/locales/hi/translation.json+++ b/src/i18n/locales/hi/translation.json@@ -6,7 +6,8 @@"unloadModel": "मॉडल अनलोड करें","model": "मॉडल","quit": "बाहर निकलें",- "cancel": "रद्द करें"+ "cancel": "रद्द करें",+ "secureInputWarning": "⚠ Secure Input ने शॉर्टकट ब्लॉक किए हैं"},"sidebar": {"general": "सामान्य",@@ -534,6 +535,26 @@"recordingBuffer": {"title": "अतिरिक्त रिकॉर्डिंग बफ़र","description": "बटन छोड़ने के बाद भी रिकॉर्डिंग जारी रखने का अतिरिक्त समय (मिलीसेकंड में), ताकि आखिरी हिस्से का ऑडियो कैप्चर हो सके. 0 = कोई अतिरिक्त बफ़र नहीं."+ },+ "keyboardDiagnostic": {+ "title": "कीबोर्ड डायग्नोस्टिक",+ "description": "जाँचता है कि कीबोर्ड इवेंट Handy तक पहुँच रहे हैं या नहीं. सिर्फ़ इवेंट की गिनती रिकॉर्ड होती है — कभी नहीं कि आपने कौन-सी कुंजियाँ दबाईं.",+ "run": "10 सेकंड का डायग्नोस्टिक चलाएँ",+ "running": "सुन रहे हैं… अपना शॉर्टकट कुछ बार दबाएँ (जैसे Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "चालू",+ "disabled": "बंद",+ "holder": "{{name}} (pid {{pid}}) ने रोका हुआ है",+ "holderUnknown": "कोई दिखने वाला ऐप नहीं",+ "keyDown": "कुंजी दबाई",+ "keyUp": "कुंजी छोड़ी",+ "flagsChanged": "मॉडिफ़ायर",+ "mouse": "माउस",+ "verdictBlocked": "Secure Input कुंजी इवेंट ब्लॉक कर रहा है — जब तक यह हल नहीं होता, सामान्य कुंजी वाले शॉर्टकट काम नहीं कर सकते.",+ "verdictSuspicious": "मॉडिफ़ायर इवेंट आए, लेकिन कोई कुंजी इवेंट नहीं — Secure Input के बंद दिखने के बावजूद कुछ कुंजियों को दबा रहा है. कृपया इसकी रिपोर्ट GitHub पर करें.",+ "verdictOk": "कुंजी इवेंट Handy तक सामान्य रूप से पहुँच रहे हैं.",+ "verdictNoEvents": "कोई इवेंट कैप्चर नहीं हुआ — क्या आपने टेस्ट के दौरान कोई कुंजी दबाई थी?",+ "failed": "डायग्नोस्टिक विफल: {{error}}"}},"about": {@@ -633,5 +654,16 @@"overlay": {"transcribing": "ट्रांसक्राइब हो रहा है...","processing": "प्रोसेस हो रहा है..."+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} शायद 1 शॉर्टकट को ब्लॉक कर रहा है",+ "blockedWithCulprit_other": "{{name}} शायद {{count}} शॉर्टकट को ब्लॉक कर रहा है",+ "blockedNoCulprit_one": "macOS अस्थायी रूप से 1 शॉर्टकट को ब्लॉक कर रहा है",+ "blockedNoCulprit_other": "macOS अस्थायी रूप से {{count}} शॉर्टकट को ब्लॉक कर रहा है",+ "recorderBlockedWithCulprit": "{{name}} शायद शॉर्टकट में बदलाव को ब्लॉक कर रहा है",+ "recorderBlockedNoCulprit": "macOS अस्थायी रूप से शॉर्टकट में बदलाव को ब्लॉक कर रहा है",+ "learnMore": "इसे कैसे ठीक करें",+ "recorderBlocked": "अभी शॉर्टकट रिकॉर्ड नहीं किए जा सकते — macOS Secure Input कुंजी इवेंट ब्लॉक कर रहा है. पहले Secure Input चेतावनी हल करें.",+ "dismiss": "खारिज करें"}}diff --git a/src/i18n/locales/it/translation.json b/src/i18n/locales/it/translation.jsonindex 5c0b9aee..d614d721 100644--- a/src/i18n/locales/it/translation.json+++ b/src/i18n/locales/it/translation.json@@ -6,7 +6,8 @@"unloadModel": "Rilascia modello","model": "Modello","quit": "Esci",- "cancel": "Annulla"+ "cancel": "Annulla",+ "secureInputWarning": "⚠ Scorciatoie bloccate da Secure Input"},"sidebar": {"general": "Generale",@@ -528,6 +529,26 @@"title": "Buffer di registrazione extra","description": "Tempo extra (in millisecondi) per continuare a registrare dopo aver rilasciato il tasto, per catturare l'audio finale. 0 = nessun buffer extra."},+ "keyboardDiagnostic": {+ "title": "Diagnostica tastiera",+ "description": "Verifica se gli eventi della tastiera arrivano a Handy. Viene registrato solo il numero di eventi, mai quali tasti premi.",+ "run": "Esegui diagnostica di 10 s",+ "running": "In ascolto… premi la tua scorciatoia alcune volte (ad es. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "abilitato",+ "disabled": "disabilitato",+ "holder": "trattenuto da {{name}} (pid {{pid}})",+ "holderUnknown": "nessun responsabile visibile",+ "keyDown": "Tasto premuto",+ "keyUp": "Tasto rilasciato",+ "flagsChanged": "Modificatori",+ "mouse": "Mouse",+ "verdictBlocked": "Secure Input sta bloccando gli eventi dei tasti: le scorciatoie che includono un tasto normale non possono funzionare finché non viene risolto.",+ "verdictSuspicious": "Sono arrivati eventi dei modificatori ma nessun evento dei tasti: qualcosa sta sopprimendo i tasti anche se Secure Input risulta disabilitato. Segnalalo su GitHub.",+ "verdictOk": "Gli eventi dei tasti arrivano a Handy normalmente.",+ "verdictNoEvents": "Nessun evento rilevato: hai premuto qualche tasto durante il test?",+ "failed": "Diagnostica non riuscita: {{error}}"+ },"whatsNewPreview": {"title": "Anteprima delle novità","description": "Apri le note di rilascio incluse più recenti senza segnarle come viste",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Novità in Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} potrebbe bloccare 1 scorciatoia",+ "blockedWithCulprit_other": "{{name}} potrebbe bloccare {{count}} scorciatoie",+ "blockedNoCulprit_one": "macOS sta bloccando temporaneamente 1 scorciatoia",+ "blockedNoCulprit_other": "macOS sta bloccando temporaneamente {{count}} scorciatoie",+ "recorderBlockedWithCulprit": "{{name}} potrebbe bloccare le modifiche alle scorciatoie",+ "recorderBlockedNoCulprit": "macOS sta bloccando temporaneamente le modifiche alle scorciatoie",+ "learnMore": "Come risolvere",+ "recorderBlocked": "Non è possibile registrare scorciatoie in questo momento: Secure Input di macOS sta bloccando gli eventi dei tasti. Risolvi prima l'avviso di Secure Input.",+ "dismiss": "Ignora"}}diff --git a/src/i18n/locales/ja/translation.json b/src/i18n/locales/ja/translation.jsonindex cac4c1d3..b43b07f1 100644--- a/src/i18n/locales/ja/translation.json+++ b/src/i18n/locales/ja/translation.json@@ -6,7 +6,8 @@"unloadModel": "モデルをアンロード","model": "モデル","quit": "終了",- "cancel": "キャンセル"+ "cancel": "キャンセル",+ "secureInputWarning": "⚠ Secure Input でショートカットがブロック中"},"sidebar": {"general": "一般",@@ -528,6 +529,26 @@"title": "追加録音バッファ","description": "キーを離した後に録音を続ける追加時間(ミリ秒)。末尾の音声を捕捉するため。0 = 追加バッファなし。"},+ "keyboardDiagnostic": {+ "title": "キーボード診断",+ "description": "キーボードイベントが Handy に届いているかを確認します。記録されるのはイベント数のみで、押したキーの内容は記録されません。",+ "run": "10 秒間の診断を実行",+ "running": "待機中… ショートカットを数回押してください (例: Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "有効",+ "disabled": "無効",+ "holder": "{{name}} (pid {{pid}}) が保持中",+ "holderUnknown": "保持元は不明",+ "keyDown": "キー押下",+ "keyUp": "キー解放",+ "flagsChanged": "修飾キー",+ "mouse": "マウス",+ "verdictBlocked": "Secure Input がキーイベントをブロックしています。解消されるまで、通常キーを含むショートカットは動作しません。",+ "verdictSuspicious": "修飾キーのイベントは届いていますが、キーイベントは届いていません。Secure Input は無効と報告されているのに、何かがキーを抑制しています。GitHub で報告してください。",+ "verdictOk": "キーイベントは Handy に正常に届いています。",+ "verdictNoEvents": "イベントを検出できませんでした。テスト中にキーを押しましたか?",+ "failed": "診断に失敗しました: {{error}}"+ },"whatsNewPreview": {"title": "新機能をプレビュー","description": "最新の同梱リリースノートを既読にせずに開く",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Handy v{{version}} の新機能"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} が1個のショートカットをブロックしている可能性があります",+ "blockedWithCulprit_other": "{{name}} が{{count}}個のショートカットをブロックしている可能性があります",+ "blockedNoCulprit_one": "macOS が一時的に1個のショートカットをブロックしています",+ "blockedNoCulprit_other": "macOS が一時的に{{count}}個のショートカットをブロックしています",+ "recorderBlockedWithCulprit": "{{name}} がショートカットの変更をブロックしている可能性があります",+ "recorderBlockedNoCulprit": "macOS が一時的にショートカットの変更をブロックしています",+ "learnMore": "解決方法",+ "recorderBlocked": "現在ショートカットを記録できません。macOS の Secure Input がキーイベントをブロックしています。先に Secure Input の警告を解消してください。",+ "dismiss": "閉じる"}}diff --git a/src/i18n/locales/ko/translation.json b/src/i18n/locales/ko/translation.jsonindex a843dc53..4ab6f759 100644--- a/src/i18n/locales/ko/translation.json+++ b/src/i18n/locales/ko/translation.json@@ -6,7 +6,8 @@"unloadModel": "모델 언로드","model": "모델","quit": "종료",- "cancel": "취소"+ "cancel": "취소",+ "secureInputWarning": "⚠ Secure Input으로 단축키가 차단됨"},"sidebar": {"general": "일반",@@ -523,6 +524,26 @@"title": "추가 녹음 버퍼","description": "키를 놓은 후 추가로 녹음을 계속하는 시간(밀리초). 후행 오디오를 캡처하기 위함. 0 = 추가 버퍼 없음."},+ "keyboardDiagnostic": {+ "title": "키보드 진단",+ "description": "키보드 이벤트가 Handy에 도달하는지 확인합니다. 이벤트 개수만 기록되며, 어떤 키를 눌렀는지는 절대 기록되지 않습니다.",+ "run": "10초 진단 실행",+ "running": "수신 중… 단축키를 몇 번 눌러 보세요 (예: Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "사용 중",+ "disabled": "사용 안 함",+ "holder": "{{name}}(pid {{pid}})이(가) 점유 중",+ "holderUnknown": "점유 중인 앱을 확인할 수 없음",+ "keyDown": "키 누름",+ "keyUp": "키 뗌",+ "flagsChanged": "조합 키",+ "mouse": "마우스",+ "verdictBlocked": "Secure Input이 키 이벤트를 차단하고 있습니다. 해결될 때까지 일반 키가 포함된 단축키는 작동할 수 없습니다.",+ "verdictSuspicious": "조합 키 이벤트는 도착했지만 키 이벤트는 없습니다. Secure Input은 꺼져 있다고 보고되지만 무언가가 키를 가로막고 있습니다. GitHub에 신고해 주세요.",+ "verdictOk": "키 이벤트가 Handy에 정상적으로 도달하고 있습니다.",+ "verdictNoEvents": "이벤트가 감지되지 않았습니다. 테스트 중에 키를 누르셨나요?",+ "failed": "진단 실패: {{error}}"+ },"paths": {"appData": "앱 데이터:","models": "모델:",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Handy v{{version}}의 새 소식"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}}이(가) 단축키 1개를 차단하고 있을 수 있습니다",+ "blockedWithCulprit_other": "{{name}}이(가) 단축키 {{count}}개를 차단하고 있을 수 있습니다",+ "blockedNoCulprit_one": "macOS가 단축키 1개를 일시적으로 차단하고 있습니다",+ "blockedNoCulprit_other": "macOS가 단축키 {{count}}개를 일시적으로 차단하고 있습니다",+ "recorderBlockedWithCulprit": "{{name}}이(가) 단축키 변경을 차단하고 있을 수 있습니다",+ "recorderBlockedNoCulprit": "macOS가 단축키 변경을 일시적으로 차단하고 있습니다",+ "learnMore": "해결 방법",+ "recorderBlocked": "지금은 단축키를 등록할 수 없습니다. macOS Secure Input이 키 이벤트를 차단하고 있습니다. Secure Input 경고를 먼저 해결하세요.",+ "dismiss": "닫기"}}diff --git a/src/i18n/locales/ne/translation.json b/src/i18n/locales/ne/translation.jsonindex 7ec013eb..be89c29a 100644--- a/src/i18n/locales/ne/translation.json+++ b/src/i18n/locales/ne/translation.json@@ -6,7 +6,8 @@"unloadModel": "मोडेल अनलोड गर्नुहोस्","model": "मोडेल","quit": "बाहिर निस्कनुहोस्",- "cancel": "रद्द गर्नुहोस्"+ "cancel": "रद्द गर्नुहोस्",+ "secureInputWarning": "⚠ Secure Input ले सर्टकटहरू रोकेको छ"},"sidebar": {"general": "सामान्य",@@ -534,6 +535,26 @@"recordingBuffer": {"title": "अतिरिक्त रेकर्डिङ बफर","description": "कि छोडेपछि अन्तिम अडियो समात्न रेकर्डिङ जारी राख्ने अतिरिक्त समय (मिलिसेकेन्डमा)। 0 = कुनै अतिरिक्त बफर छैन।"+ },+ "keyboardDiagnostic": {+ "title": "किबोर्ड डायग्नोस्टिक",+ "description": "किबोर्ड इभेन्टहरू Handy सम्म पुग्छन् कि पुग्दैनन् भनी जाँच्छ। इभेन्टको संख्या मात्र रेकर्ड हुन्छ — तपाईंले कुन कुञ्जी थिच्नुभयो भन्ने कहिल्यै होइन।",+ "run": "१० सेकेन्डको डायग्नोस्टिक चलाउनुहोस्",+ "running": "सुनिरहेको छ… आफ्नो सर्टकट केही पटक थिच्नुहोस् (जस्तै Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "सक्षम",+ "disabled": "अक्षम",+ "holder": "{{name}} (pid {{pid}}) ले समातेको छ",+ "holderUnknown": "देखिने कुनै धारक छैन",+ "keyDown": "कुञ्जी थिचिएको",+ "keyUp": "कुञ्जी छाडिएको",+ "flagsChanged": "मोडिफायर",+ "mouse": "माउस",+ "verdictBlocked": "Secure Input ले कुञ्जी इभेन्टहरू रोकिरहेको छ — यो समाधान नभएसम्म सामान्य कुञ्जी भएका सर्टकटहरूले काम गर्न सक्दैनन्।",+ "verdictSuspicious": "मोडिफायर इभेन्टहरू आए तर कुञ्जी इभेन्ट आएनन् — Secure Input अक्षम देखिए पनि केहीले कुञ्जीहरू दबाइरहेको छ। कृपया यसको रिपोर्ट GitHub मा गर्नुहोस्।",+ "verdictOk": "कुञ्जी इभेन्टहरू Handy सम्म सामान्य रूपमा पुगिरहेका छन्।",+ "verdictNoEvents": "कुनै इभेन्ट कैद भएन — के तपाईंले परीक्षणको क्रममा कुनै कुञ्जी थिच्नुभयो?",+ "failed": "डायग्नोस्टिक असफल: {{error}}"}},"about": {@@ -633,5 +654,16 @@"overlay": {"transcribing": "ट्रान्सक्राइब गरिँदैछ...","processing": "प्रशोधन गरिँदैछ..."+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} ले 1 सर्टकट रोकिरहेको हुन सक्छ",+ "blockedWithCulprit_other": "{{name}} ले {{count}} सर्टकटहरू रोकिरहेको हुन सक्छ",+ "blockedNoCulprit_one": "macOS ले अस्थायी रूपमा 1 सर्टकट रोकिरहेको छ",+ "blockedNoCulprit_other": "macOS ले अस्थायी रूपमा {{count}} सर्टकटहरू रोकिरहेको छ",+ "recorderBlockedWithCulprit": "{{name}} ले सर्टकट परिवर्तन रोकिरहेको हुन सक्छ",+ "recorderBlockedNoCulprit": "macOS ले अस्थायी रूपमा सर्टकट परिवर्तन रोकिरहेको छ",+ "learnMore": "यसलाई कसरी ठिक गर्ने",+ "recorderBlocked": "अहिले सर्टकट रेकर्ड गर्न सकिँदैन — macOS Secure Input ले कुञ्जी इभेन्टहरू रोकिरहेको छ। पहिले Secure Input चेतावनी समाधान गर्नुहोस्।",+ "dismiss": "हटाउनुहोस्"}}diff --git a/src/i18n/locales/nl/translation.json b/src/i18n/locales/nl/translation.jsonindex 9d9c4946..68f89f12 100644--- a/src/i18n/locales/nl/translation.json+++ b/src/i18n/locales/nl/translation.json@@ -6,7 +6,8 @@"unloadModel": "Model ontladen","model": "Model","quit": "Afsluiten",- "cancel": "Annuleren"+ "cancel": "Annuleren",+ "secureInputWarning": "⚠ Sneltoetsen geblokkeerd door Secure Input"},"sidebar": {"general": "Algemeen",@@ -534,6 +535,26 @@"recordingBuffer": {"title": "Extra opnamebuffer","description": "Extra tijd (in milliseconden) om te blijven opnemen nadat je de toets loslaat, om naloopaudio op te vangen. 0 = geen extra buffer."+ },+ "keyboardDiagnostic": {+ "title": "Toetsenborddiagnose",+ "description": "Controleert of toetsenbordgebeurtenissen Handy bereiken. Alleen het aantal gebeurtenissen wordt vastgelegd — nooit welke toetsen je indrukt.",+ "run": "Diagnose van 10 s uitvoeren",+ "running": "Luisteren… druk je sneltoets een paar keer in (bijv. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "ingeschakeld",+ "disabled": "uitgeschakeld",+ "holder": "vastgehouden door {{name}} (pid {{pid}})",+ "holderUnknown": "geen zichtbare veroorzaker",+ "keyDown": "Toets ingedrukt",+ "keyUp": "Toets losgelaten",+ "flagsChanged": "Modificatietoetsen",+ "mouse": "Muis",+ "verdictBlocked": "Secure Input blokkeert toetsgebeurtenissen — sneltoetsen met een gewone toets kunnen pas weer werken als dit is opgelost.",+ "verdictSuspicious": "Er kwamen wel modificatiegebeurtenissen binnen, maar geen toetsgebeurtenissen — iets onderdrukt toetsen terwijl Secure Input als uitgeschakeld wordt gemeld. Meld dit op GitHub.",+ "verdictOk": "Toetsgebeurtenissen bereiken Handy normaal.",+ "verdictNoEvents": "Geen gebeurtenissen vastgelegd — heb je tijdens de test toetsen ingedrukt?",+ "failed": "Diagnose mislukt: {{error}}"}},"about": {@@ -633,5 +654,16 @@"overlay": {"transcribing": "Transcriberen...","processing": "Verwerken..."+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} blokkeert mogelijk 1 sneltoets",+ "blockedWithCulprit_other": "{{name}} blokkeert mogelijk {{count}} sneltoetsen",+ "blockedNoCulprit_one": "macOS blokkeert tijdelijk 1 sneltoets",+ "blockedNoCulprit_other": "macOS blokkeert tijdelijk {{count}} sneltoetsen",+ "recorderBlockedWithCulprit": "{{name}} blokkeert mogelijk wijzigingen aan sneltoetsen",+ "recorderBlockedNoCulprit": "macOS blokkeert tijdelijk wijzigingen aan sneltoetsen",+ "learnMore": "Hoe je dit oplost",+ "recorderBlocked": "Sneltoetsen kunnen nu niet worden opgenomen — Secure Input van macOS blokkeert toetsgebeurtenissen. Los eerst de Secure Input-waarschuwing op.",+ "dismiss": "Sluiten"}}diff --git a/src/i18n/locales/pl/translation.json b/src/i18n/locales/pl/translation.jsonindex ff2570f9..c1f88fd7 100644--- a/src/i18n/locales/pl/translation.json+++ b/src/i18n/locales/pl/translation.json@@ -6,7 +6,8 @@"unloadModel": "Zwolnij model","model": "Model","quit": "Zamknij",- "cancel": "Anuluj"+ "cancel": "Anuluj",+ "secureInputWarning": "⚠ Skróty zablokowane przez Secure Input"},"sidebar": {"general": "Ogólne",@@ -528,6 +529,26 @@"title": "Dodatkowy bufor nagrywania","description": "Dodatkowy czas (w milisekundach) na kontynuowanie nagrywania po zwolnieniu klawisza, aby przechwycić końcowy dźwięk. 0 = brak dodatkowego bufora."},+ "keyboardDiagnostic": {+ "title": "Diagnostyka klawiatury",+ "description": "Sprawdza, czy zdarzenia klawiatury docierają do Handy. Zapisywana jest tylko liczba zdarzeń — nigdy to, które klawisze naciskasz.",+ "run": "Uruchom 10-sekundową diagnostykę",+ "running": "Nasłuchiwanie… naciśnij swój skrót kilka razy (np. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "włączony",+ "disabled": "wyłączony",+ "holder": "trzymany przez {{name}} (pid {{pid}})",+ "holderUnknown": "brak widocznego posiadacza",+ "keyDown": "Klawisz wciśnięty",+ "keyUp": "Klawisz zwolniony",+ "flagsChanged": "Modyfikatory",+ "mouse": "Mysz",+ "verdictBlocked": "Secure Input blokuje zdarzenia klawiszy — skróty zawierające zwykły klawisz nie zadziałają, dopóki nie zostanie to rozwiązane.",+ "verdictSuspicious": "Dotarły zdarzenia modyfikatorów, ale żadnych zdarzeń klawiszy — coś tłumi klawisze, mimo że Secure Input jest zgłaszany jako wyłączony. Zgłoś to na GitHubie.",+ "verdictOk": "Zdarzenia klawiszy docierają do Handy normalnie.",+ "verdictNoEvents": "Nie przechwycono żadnych zdarzeń — czy w trakcie testu naciśnięto jakieś klawisze?",+ "failed": "Diagnostyka nie powiodła się: {{error}}"+ },"whatsNewPreview": {"title": "Podgląd nowości","description": "Otwórz najnowsze dołączone informacje o wydaniu bez oznaczania ich jako wyświetlone",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Nowości w Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} może blokować 1 skrót",+ "blockedWithCulprit_other": "{{name}} może blokować {{count}} skrótów",+ "blockedNoCulprit_one": "macOS tymczasowo blokuje 1 skrót",+ "blockedNoCulprit_other": "macOS tymczasowo blokuje {{count}} skrótów",+ "recorderBlockedWithCulprit": "{{name}} może blokować zmiany skrótów",+ "recorderBlockedNoCulprit": "macOS tymczasowo blokuje zmiany skrótów",+ "learnMore": "Jak to naprawić",+ "recorderBlocked": "Nie można teraz nagrać skrótu — Secure Input w macOS blokuje zdarzenia klawiszy. Najpierw rozwiąż ostrzeżenie o Secure Input.",+ "dismiss": "Odrzuć"}}diff --git a/src/i18n/locales/pt/translation.json b/src/i18n/locales/pt/translation.jsonindex 1bf553ad..989a3930 100644--- a/src/i18n/locales/pt/translation.json+++ b/src/i18n/locales/pt/translation.json@@ -6,7 +6,8 @@"unloadModel": "Descarregar modelo","model": "Modelo","quit": "Sair",- "cancel": "Cancelar"+ "cancel": "Cancelar",+ "secureInputWarning": "⚠ Atalhos bloqueados pelo Secure Input"},"sidebar": {"general": "Geral",@@ -528,6 +529,26 @@"title": "Buffer de gravação extra","description": "Tempo extra (em milissegundos) para continuar gravando após soltar a tecla, para capturar áudio restante. 0 = sem buffer extra."},+ "keyboardDiagnostic": {+ "title": "Diagnóstico do teclado",+ "description": "Verifica se os eventos de teclado chegam ao Handy. Apenas a contagem de eventos é registrada — nunca quais teclas você pressiona.",+ "run": "Executar diagnóstico de 10 s",+ "running": "Ouvindo… pressione seu atalho algumas vezes (ex.: Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "ativado",+ "disabled": "desativado",+ "holder": "retido por {{name}} (pid {{pid}})",+ "holderUnknown": "sem responsável visível",+ "keyDown": "Tecla pressionada",+ "keyUp": "Tecla liberada",+ "flagsChanged": "Modificadores",+ "mouse": "Mouse",+ "verdictBlocked": "O Secure Input está bloqueando os eventos de tecla — atalhos que incluem uma tecla normal não funcionam até que isso seja resolvido.",+ "verdictSuspicious": "Chegaram eventos de modificadores, mas nenhum evento de tecla — algo está suprimindo as teclas mesmo com o Secure Input indicando desativado. Por favor, relate isso no GitHub.",+ "verdictOk": "Os eventos de tecla estão chegando normalmente ao Handy.",+ "verdictNoEvents": "Nenhum evento capturado — você pressionou alguma tecla durante o teste?",+ "failed": "Falha no diagnóstico: {{error}}"+ },"whatsNewPreview": {"title": "Pré-visualizar novidades","description": "Abrir a nota de versão incorporada mais recente sem marcá-la como vista",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Novidades no Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} pode estar bloqueando 1 atalho",+ "blockedWithCulprit_other": "{{name}} pode estar bloqueando {{count}} atalhos",+ "blockedNoCulprit_one": "O macOS está bloqueando temporariamente 1 atalho",+ "blockedNoCulprit_other": "O macOS está bloqueando temporariamente {{count}} atalhos",+ "recorderBlockedWithCulprit": "{{name}} pode estar bloqueando alterações nos atalhos",+ "recorderBlockedNoCulprit": "O macOS está bloqueando temporariamente alterações nos atalhos",+ "learnMore": "Como resolver isso",+ "recorderBlocked": "Não é possível gravar atalhos agora — o Secure Input do macOS está bloqueando os eventos de tecla. Resolva primeiro o aviso do Secure Input.",+ "dismiss": "Dispensar"}}diff --git a/src/i18n/locales/ru/translation.json b/src/i18n/locales/ru/translation.jsonindex 53db4a3d..c2debd27 100644--- a/src/i18n/locales/ru/translation.json+++ b/src/i18n/locales/ru/translation.json@@ -6,7 +6,8 @@"unloadModel": "Выгрузить модель","model": "Модель","quit": "Выход",- "cancel": "Отмена"+ "cancel": "Отмена",+ "secureInputWarning": "⚠ Сочетания клавиш заблокированы Secure Input"},"sidebar": {"general": "Общие",@@ -528,6 +529,26 @@"title": "Дополнительный буфер записи","description": "Дополнительное время (в миллисекундах) для продолжения записи после отпускания клавиши, чтобы захватить завершающий звук. 0 = без дополнительного буфера."},+ "keyboardDiagnostic": {+ "title": "Диагностика клавиатуры",+ "description": "Проверяет, доходят ли события клавиатуры до Handy. Записывается только количество событий — никогда то, какие клавиши вы нажимаете.",+ "run": "Запустить 10-секундную диагностику",+ "running": "Прослушивание… нажмите своё сочетание клавиш несколько раз (например, Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "включён",+ "disabled": "выключен",+ "holder": "удерживает {{name}} (pid {{pid}})",+ "holderUnknown": "видимый владелец не найден",+ "keyDown": "Нажатие клавиши",+ "keyUp": "Отпускание клавиши",+ "flagsChanged": "Модификаторы",+ "mouse": "Мышь",+ "verdictBlocked": "Secure Input блокирует события клавиш — сочетания с обычной клавишей не смогут работать, пока это не будет устранено.",+ "verdictSuspicious": "События модификаторов приходят, а события клавиш — нет: что-то подавляет клавиши, хотя Secure Input отмечен как выключенный. Пожалуйста, сообщите об этом на GitHub.",+ "verdictOk": "События клавиш доходят до Handy нормально.",+ "verdictNoEvents": "События не зафиксированы — вы нажимали клавиши во время теста?",+ "failed": "Диагностика не удалась: {{error}}"+ },"whatsNewPreview": {"title": "Предпросмотр новинок","description": "Открыть последние встроенные примечания к выпуску, не отмечая их как просмотренные",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Новое в Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} может блокировать 1 сочетание клавиш",+ "blockedWithCulprit_other": "{{name}} может блокировать {{count}} сочетаний клавиш",+ "blockedNoCulprit_one": "macOS временно блокирует 1 сочетание клавиш",+ "blockedNoCulprit_other": "macOS временно блокирует {{count}} сочетаний клавиш",+ "recorderBlockedWithCulprit": "{{name}} может блокировать изменение сочетаний клавиш",+ "recorderBlockedNoCulprit": "macOS временно блокирует изменение сочетаний клавиш",+ "learnMore": "Как это исправить",+ "recorderBlocked": "Сейчас нельзя записать сочетание клавиш — Secure Input в macOS блокирует события клавиш. Сначала устраните предупреждение о Secure Input.",+ "dismiss": "Скрыть"}}diff --git a/src/i18n/locales/sv/translation.json b/src/i18n/locales/sv/translation.jsonindex dc7294c8..e76be748 100644--- a/src/i18n/locales/sv/translation.json+++ b/src/i18n/locales/sv/translation.json@@ -6,7 +6,8 @@"unloadModel": "Avlasta modell","model": "Modell","quit": "Avsluta",- "cancel": "Avbryt"+ "cancel": "Avbryt",+ "secureInputWarning": "⚠ Kortkommandon blockeras av Secure Input"},"sidebar": {"general": "Allmänt",@@ -528,6 +529,26 @@"title": "Extra inspelningsbuffert","description": "Extra tid (i millisekunder) för att fortsätta spela in efter att du släppt tangenten, för att fånga upp avslutande ljud. 0 = ingen extra buffert."},+ "keyboardDiagnostic": {+ "title": "Tangentbordsdiagnostik",+ "description": "Kontrollerar om tangentbordshändelser når Handy. Endast antalet händelser registreras — aldrig vilka tangenter du trycker på.",+ "run": "Kör 10 s diagnostik",+ "running": "Lyssnar… tryck på ditt kortkommando några gånger (t.ex. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "aktiverat",+ "disabled": "inaktiverat",+ "holder": "hålls av {{name}} (pid {{pid}})",+ "holderUnknown": "ingen synlig innehavare",+ "keyDown": "Tangent ned",+ "keyUp": "Tangent upp",+ "flagsChanged": "Modifierare",+ "mouse": "Mus",+ "verdictBlocked": "Secure Input blockerar tangenthändelser — kortkommandon med en vanlig tangent kan inte fungera förrän det är löst.",+ "verdictSuspicious": "Modifierarhändelser kom fram men inga tangenthändelser — något undertrycker tangenter trots att Secure Input rapporteras som inaktiverat. Rapportera gärna detta på GitHub.",+ "verdictOk": "Tangenthändelser når Handy som vanligt.",+ "verdictNoEvents": "Inga händelser fångades — tryckte du på några tangenter under testet?",+ "failed": "Diagnostiken misslyckades: {{error}}"+ },"whatsNewPreview": {"title": "Förhandsvisa nyheter","description": "Öppna den senaste medföljande versionsinformationen utan att markera den som visad",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Nytt i Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} kanske blockerar 1 kortkommando",+ "blockedWithCulprit_other": "{{name}} kanske blockerar {{count}} kortkommandon",+ "blockedNoCulprit_one": "macOS blockerar tillfälligt 1 kortkommando",+ "blockedNoCulprit_other": "macOS blockerar tillfälligt {{count}} kortkommandon",+ "recorderBlockedWithCulprit": "{{name}} kanske blockerar ändringar av kortkommandon",+ "recorderBlockedNoCulprit": "macOS blockerar tillfälligt ändringar av kortkommandon",+ "learnMore": "Så här löser du det",+ "recorderBlocked": "Det går inte att spela in kortkommandon just nu — macOS Secure Input blockerar tangenthändelser. Lös varningen om Secure Input först.",+ "dismiss": "Avfärda"}}diff --git a/src/i18n/locales/tr/translation.json b/src/i18n/locales/tr/translation.jsonindex 7bf05266..369690b8 100644--- a/src/i18n/locales/tr/translation.json+++ b/src/i18n/locales/tr/translation.json@@ -6,7 +6,8 @@"unloadModel": "Modeli boşalt","model": "Model","quit": "Çıkış",- "cancel": "İptal"+ "cancel": "İptal",+ "secureInputWarning": "⚠ Kısayollar Secure Input tarafından engelleniyor"},"sidebar": {"general": "Genel",@@ -528,6 +529,26 @@"title": "Ekstra kayıt tamponu","description": "Tuşu bıraktıktan sonra arka plandaki sesi yakalamak için kaydı sürdürme süresi (milisaniye). 0 = ekstra tampon yok."},+ "keyboardDiagnostic": {+ "title": "Klavye Tanılaması",+ "description": "Klavye olaylarının Handy'ye ulaşıp ulaşmadığını denetler. Yalnızca olay sayıları kaydedilir — hangi tuşlara bastığınız asla kaydedilmez.",+ "run": "10 sn'lik tanılamayı çalıştır",+ "running": "Dinleniyor… kısayolunuza birkaç kez basın (ör. Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "etkin",+ "disabled": "devre dışı",+ "holder": "{{name}} tarafından tutuluyor (pid {{pid}})",+ "holderUnknown": "görünür bir sahip yok",+ "keyDown": "Tuş basma",+ "keyUp": "Tuş bırakma",+ "flagsChanged": "Değiştiriciler",+ "mouse": "Fare",+ "verdictBlocked": "Secure Input tuş olaylarını engelliyor — normal tuş içeren kısayollar bu sorun çözülene kadar çalışamaz.",+ "verdictSuspicious": "Değiştirici olayları geldi ancak hiç tuş olayı gelmedi — Secure Input devre dışı görünmesine rağmen bir şey tuşları bastırıyor. Lütfen bunu GitHub'da bildirin.",+ "verdictOk": "Tuş olayları Handy'ye normal şekilde ulaşıyor.",+ "verdictNoEvents": "Hiç olay yakalanmadı — test sırasında herhangi bir tuşa bastınız mı?",+ "failed": "Tanılama başarısız: {{error}}"+ },"whatsNewPreview": {"title": "Yenilikleri Önizle","description": "En son paketlenmiş sürüm notunu görüldü olarak işaretlemeden aç",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Handy v{{version}} yenilikleri"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} 1 kısayolu engelliyor olabilir",+ "blockedWithCulprit_other": "{{name}} {{count}} kısayolu engelliyor olabilir",+ "blockedNoCulprit_one": "macOS geçici olarak 1 kısayolu engelliyor",+ "blockedNoCulprit_other": "macOS geçici olarak {{count}} kısayolu engelliyor",+ "recorderBlockedWithCulprit": "{{name}} kısayol değişikliklerini engelliyor olabilir",+ "recorderBlockedNoCulprit": "macOS geçici olarak kısayol değişikliklerini engelliyor",+ "learnMore": "Bu nasıl düzeltilir",+ "recorderBlocked": "Şu anda kısayol kaydedilemiyor — macOS Secure Input tuş olaylarını engelliyor. Önce Secure Input uyarısını giderin.",+ "dismiss": "Kapat"}}diff --git a/src/i18n/locales/uk/translation.json b/src/i18n/locales/uk/translation.jsonindex 90e302fa..b0a06c7f 100644--- a/src/i18n/locales/uk/translation.json+++ b/src/i18n/locales/uk/translation.json@@ -6,7 +6,8 @@"unloadModel": "Вивантажити модель","model": "Модель","quit": "Вийти",- "cancel": "Скасувати"+ "cancel": "Скасувати",+ "secureInputWarning": "⚠ Комбінації клавіш заблоковано Secure Input"},"sidebar": {"general": "Загальні",@@ -528,6 +529,26 @@"title": "Додатковий буфер запису","description": "Додатковий час (у мілісекундах) для продовження запису після відпускання клавіші, щоб захопити завершальний звук. 0 = без додаткового буфера."},+ "keyboardDiagnostic": {+ "title": "Діагностика клавіатури",+ "description": "Перевіряє, чи доходять події клавіатури до Handy. Записується лише кількість подій — ніколи те, які клавіші ви натискаєте.",+ "run": "Запустити 10-секундну діагностику",+ "running": "Прослуховування… натисніть свою комбінацію кілька разів (наприклад, Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "увімкнено",+ "disabled": "вимкнено",+ "holder": "утримує {{name}} (pid {{pid}})",+ "holderUnknown": "видимого власника не знайдено",+ "keyDown": "Натискання клавіші",+ "keyUp": "Відпускання клавіші",+ "flagsChanged": "Модифікатори",+ "mouse": "Миша",+ "verdictBlocked": "Secure Input блокує події клавіш — комбінації зі звичайною клавішею не працюватимуть, доки це не буде усунуто.",+ "verdictSuspicious": "Події модифікаторів надходять, а події клавіш — ні: щось пригнічує клавіші, хоча Secure Input позначено як вимкнений. Будь ласка, повідомте про це на GitHub.",+ "verdictOk": "Події клавіш надходять до Handy нормально.",+ "verdictNoEvents": "Подій не зафіксовано — ви натискали клавіші під час тесту?",+ "failed": "Не вдалося виконати діагностику: {{error}}"+ },"whatsNewPreview": {"title": "Попередній перегляд новин","description": "Відкрити останні вбудовані примітки до випуску, не позначаючи їх як переглянуті",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Нове в Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} може блокувати 1 комбінацію клавіш",+ "blockedWithCulprit_other": "{{name}} може блокувати {{count}} комбінацій клавіш",+ "blockedNoCulprit_one": "macOS тимчасово блокує 1 комбінацію клавіш",+ "blockedNoCulprit_other": "macOS тимчасово блокує {{count}} комбінацій клавіш",+ "recorderBlockedWithCulprit": "{{name}} може блокувати зміну комбінацій клавіш",+ "recorderBlockedNoCulprit": "macOS тимчасово блокує зміну комбінацій клавіш",+ "learnMore": "Як це виправити",+ "recorderBlocked": "Зараз неможливо записати комбінацію — Secure Input у macOS блокує події клавіш. Спершу усуньте попередження про Secure Input.",+ "dismiss": "Приховати"}}diff --git a/src/i18n/locales/vi/translation.json b/src/i18n/locales/vi/translation.jsonindex 2a636c67..045c81b7 100644--- a/src/i18n/locales/vi/translation.json+++ b/src/i18n/locales/vi/translation.json@@ -6,7 +6,8 @@"unloadModel": "Dỡ mô hình","model": "Mô hình","quit": "Thoát",- "cancel": "Hủy"+ "cancel": "Hủy",+ "secureInputWarning": "⚠ Phím tắt bị Secure Input chặn"},"sidebar": {"general": "Chung",@@ -528,6 +529,26 @@"title": "Bộ đệm ghi âm thêm","description": "Thời gian thêm (tính bằng mili giây) để tiếp tục ghi âm sau khi nhả phím, để thu âm thanh cuối. 0 = không có bộ đệm thêm."},+ "keyboardDiagnostic": {+ "title": "Chẩn đoán bàn phím",+ "description": "Kiểm tra xem các sự kiện bàn phím có đến được Handy hay không. Chỉ số lượng sự kiện được ghi lại — không bao giờ ghi lại bạn bấm phím nào.",+ "run": "Chạy chẩn đoán 10 giây",+ "running": "Đang lắng nghe… hãy bấm phím tắt của bạn vài lần (ví dụ: Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "đang bật",+ "disabled": "đang tắt",+ "holder": "bị {{name}} (pid {{pid}}) giữ",+ "holderUnknown": "không thấy tiến trình nào giữ",+ "keyDown": "Nhấn phím",+ "keyUp": "Nhả phím",+ "flagsChanged": "Phím bổ trợ",+ "mouse": "Chuột",+ "verdictBlocked": "Secure Input đang chặn các sự kiện phím — phím tắt có chứa phím thường không thể hoạt động cho đến khi vấn đề này được xử lý.",+ "verdictSuspicious": "Có sự kiện phím bổ trợ nhưng không có sự kiện phím nào — thứ gì đó đang chặn phím dù Secure Input báo là đang tắt. Vui lòng báo cáo việc này trên GitHub.",+ "verdictOk": "Các sự kiện phím đang đến Handy bình thường.",+ "verdictNoEvents": "Không ghi nhận sự kiện nào — bạn có bấm phím nào trong lúc kiểm tra không?",+ "failed": "Chẩn đoán thất bại: {{error}}"+ },"whatsNewPreview": {"title": "Xem trước điểm mới","description": "Mở ghi chú phát hành mới nhất được đóng gói mà không đánh dấu là đã xem",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Điểm mới trong Handy v{{version}}"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} có thể đang chặn 1 phím tắt",+ "blockedWithCulprit_other": "{{name}} có thể đang chặn {{count}} phím tắt",+ "blockedNoCulprit_one": "macOS đang tạm thời chặn 1 phím tắt",+ "blockedNoCulprit_other": "macOS đang tạm thời chặn {{count}} phím tắt",+ "recorderBlockedWithCulprit": "{{name}} có thể đang chặn việc thay đổi phím tắt",+ "recorderBlockedNoCulprit": "macOS đang tạm thời chặn việc thay đổi phím tắt",+ "learnMore": "Cách khắc phục",+ "recorderBlocked": "Hiện không thể ghi phím tắt — Secure Input của macOS đang chặn các sự kiện phím. Hãy xử lý cảnh báo Secure Input trước.",+ "dismiss": "Bỏ qua"}}diff --git a/src/i18n/locales/zh-TW/translation.json b/src/i18n/locales/zh-TW/translation.jsonindex 7ad33db7..1dcf6799 100644--- a/src/i18n/locales/zh-TW/translation.json+++ b/src/i18n/locales/zh-TW/translation.json@@ -6,7 +6,8 @@"unloadModel": "卸載模型","model": "模型","quit": "結束",- "cancel": "取消"+ "cancel": "取消",+ "secureInputWarning": "⚠ 快捷鍵被 Secure Input 阻擋"},"sidebar": {"general": "一般",@@ -528,6 +529,26 @@"title": "額外錄音緩衝","description": "放開按鍵後繼續錄音的額外時間(毫秒),以捕捉尾音。0 = 無額外緩衝。"},+ "keyboardDiagnostic": {+ "title": "鍵盤診斷",+ "description": "檢查鍵盤事件是否能送達 Handy。只會記錄事件數量,絕不記錄您按了哪些按鍵。",+ "run": "執行 10 秒診斷",+ "running": "正在監聽… 請按幾次您的快捷鍵(例如 Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "已啟用",+ "disabled": "已停用",+ "holder": "被 {{name}}(pid {{pid}})占用",+ "holderUnknown": "找不到占用的程式",+ "keyDown": "按鍵按下",+ "keyUp": "按鍵放開",+ "flagsChanged": "修飾鍵",+ "mouse": "滑鼠",+ "verdictBlocked": "Secure Input 正在阻擋按鍵事件——在問題解決前,包含一般按鍵的快捷鍵無法運作。",+ "verdictSuspicious": "收到了修飾鍵事件,但沒有按鍵事件——即使 Secure Input 回報為已停用,仍有程式在抑制按鍵。請在 GitHub 上回報此問題。",+ "verdictOk": "按鍵事件正常送達 Handy。",+ "verdictNoEvents": "未擷取到任何事件——測試期間您有按鍵嗎?",+ "failed": "診斷失敗:{{error}}"+ },"whatsNewPreview": {"title": "預覽新功能","description": "開啟最新內建版本資訊,且不標記為已看過",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Handy v{{version}} 新功能"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} 可能正在阻擋 1 個快捷鍵",+ "blockedWithCulprit_other": "{{name}} 可能正在阻擋 {{count}} 個快捷鍵",+ "blockedNoCulprit_one": "macOS 正在暫時阻擋 1 個快捷鍵",+ "blockedNoCulprit_other": "macOS 正在暫時阻擋 {{count}} 個快捷鍵",+ "recorderBlockedWithCulprit": "{{name}} 可能正在阻擋快捷鍵變更",+ "recorderBlockedNoCulprit": "macOS 正在暫時阻擋快捷鍵變更",+ "learnMore": "如何解決",+ "recorderBlocked": "目前無法錄製快捷鍵——macOS 的 Secure Input 正在阻擋按鍵事件。請先解決 Secure Input 警告。",+ "dismiss": "關閉"}}diff --git a/src/i18n/locales/zh/translation.json b/src/i18n/locales/zh/translation.jsonindex eff41423..b6a78e3c 100644--- a/src/i18n/locales/zh/translation.json+++ b/src/i18n/locales/zh/translation.json@@ -6,7 +6,8 @@"unloadModel": "卸载模型","model": "模型","quit": "退出",- "cancel": "取消"+ "cancel": "取消",+ "secureInputWarning": "⚠ 快捷键被 Secure Input 阻止"},"sidebar": {"general": "通用",@@ -528,6 +529,26 @@"title": "额外录音缓冲","description": "放开按键后继续录音的额外时间(毫秒),以捕捉尾音。0 = 无额外缓冲。"},+ "keyboardDiagnostic": {+ "title": "键盘诊断",+ "description": "检查键盘事件是否能到达 Handy。仅记录事件数量,绝不记录您按了哪些键。",+ "run": "运行 10 秒诊断",+ "running": "正在监听… 请按几次您的快捷键(例如 Option+Space)",+ "secureInputLabel": "Secure Input",+ "enabled": "已启用",+ "disabled": "已禁用",+ "holder": "被 {{name}}(pid {{pid}})占用",+ "holderUnknown": "未发现占用方",+ "keyDown": "按键按下",+ "keyUp": "按键释放",+ "flagsChanged": "修饰键",+ "mouse": "鼠标",+ "verdictBlocked": "Secure Input 正在阻止按键事件——在问题解决前,包含普通按键的快捷键无法工作。",+ "verdictSuspicious": "收到了修饰键事件,但没有按键事件——尽管 Secure Input 报告为已禁用,仍有程序在抑制按键。请在 GitHub 上反馈此问题。",+ "verdictOk": "按键事件正常到达 Handy。",+ "verdictNoEvents": "未捕获到任何事件——测试期间您按过键吗?",+ "failed": "诊断失败:{{error}}"+ },"whatsNewPreview": {"title": "预览新功能","description": "打开最新内置发行说明,且不标记为已查看",@@ -633,5 +654,16 @@},"whatsNew": {"title": "Handy v{{version}} 新功能"+ },+ "secureInput": {+ "blockedWithCulprit_one": "{{name}} 可能正在阻止 1 个快捷键",+ "blockedWithCulprit_other": "{{name}} 可能正在阻止 {{count}} 个快捷键",+ "blockedNoCulprit_one": "macOS 正在暂时阻止 1 个快捷键",+ "blockedNoCulprit_other": "macOS 正在暂时阻止 {{count}} 个快捷键",+ "recorderBlockedWithCulprit": "{{name}} 可能正在阻止快捷键更改",+ "recorderBlockedNoCulprit": "macOS 正在暂时阻止快捷键更改",+ "learnMore": "如何解决",+ "recorderBlocked": "当前无法录制快捷键——macOS 的 Secure Input 正在阻止按键事件。请先解决 Secure Input 警告。",+ "dismiss": "关闭"}}diff --git a/src/styles/theme.css b/src/styles/theme.cssindex 2494b5b0..d562c281 100644--- a/src/styles/theme.css+++ b/src/styles/theme.css@@ -14,6 +14,14 @@--dark-color-logo-primary: #f28cbb;--dark-color-logo-stroke: #fad1ed;+ /* Semantic status colors. First used by SecureInputWarning; intended to+ replace the ad-hoc yellow-500/red-500 usages (e.g. ui/Alert.tsx) over+ time so status styling is themeable from one place. */+ --light-color-warning: #d97706;+ --light-color-error: #dc2626;+ --dark-color-warning: #fbbf24;+ --dark-color-error: #f87171;+/* Tokens that do not change between light and dark */--color-background-ui: #da5893;--color-text-stroke: #f6f6f6;@@ -25,6 +33,8 @@--color-background: var(--light-color-background);--color-logo-primary: var(--light-color-logo-primary);--color-logo-stroke: var(--light-color-logo-stroke);+ --color-warning: var(--light-color-warning);+ --color-error: var(--light-color-error);}@media (prefers-color-scheme: dark) {@@ -33,5 +43,7 @@--color-background: var(--dark-color-background);--color-logo-primary: var(--dark-color-logo-primary);--color-logo-stroke: var(--dark-color-logo-stroke);+ --color-warning: var(--dark-color-warning);+ --color-error: var(--dark-color-error);}}