Skip to content

armgit / Handy

Public Imported from GitHub
0

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.png
new file mode 100644
index 00000000..55e84e83
Binary files /dev/null and b/src-tauri/resources/handy_warning.png differ
diff --git a/src-tauri/resources/tray_idle_warning.png b/src-tauri/resources/tray_idle_warning.png
new file mode 100644
index 00000000..7fc1f6cf
Binary files /dev/null and b/src-tauri/resources/tray_idle_warning.png differ
diff --git a/src-tauri/resources/tray_idle_warning_dark.png b/src-tauri/resources/tray_idle_warning_dark.png
new file mode 100644
index 00000000..6f1619f0
Binary files /dev/null and b/src-tauri/resources/tray_idle_warning_dark.png differ
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 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 shortcuts
crate::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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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 settings
settings.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 binding
Ok(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 ones
let reset_bindings = register_all_shortcuts_for_implementation(&app, new_impl);
+ crate::secure_input::reconcile_fallback(&app);
// Emit event to notify frontend of the change
let _ = 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.rs
index 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.rs
index 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 state
app.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.css
index 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.tsx
index 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.ts
index 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.tsx
new file mode 100644
index 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.tsx
index 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 canceled
setOriginalBinding(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.tsx
index 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.tsx
new file mode 100644
index 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.tsx
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.css
index 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);
}
}