Various fixes

Author: Pajn

Cargo.lock

@@ -56,6 +56,9 @@ tokio = { version = "1", features = ["full"] }
 objc2 = "0.6"
 objc2-app-kit = "0.3"
 
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(feature, values("cargo-clippy"))'] }
+
 [profile.release]
 opt-level = 2
 lto = true
@@ -73,4 +76,3 @@ long_description = "Pixie is a macOS window focus tool with a leader key system
 osx_minimum_system_version = "10.15"
 osx_info_plist_exts = ["Info.plist.ext"]
 
-

Cargo.toml

@@ -241,29 +241,14 @@ pub fn get_focused_window_with_retry(
 pub struct WindowInfo {
     pub pid: i32,
     pub title: String,
-    pub role: String,
-}
-
-impl WindowInfo {
-    pub fn display_string(&self) -> String {
-        let app_name = get_app_name(self.pid).unwrap_or_else(|_| "Unknown".to_string());
-        if self.title.is_empty() {
-            format!("{} (PID: {})", app_name, self.pid)
-        } else {
-            format!("{} - \"{}\" (PID: {})", app_name, self.title, self.pid)
-        }
-    }
 }
 
 /// Get information about a window element
 pub fn get_window_info(element: &AXUIElement) -> Result<WindowInfo, PixieError> {
     let title = element.title().map(|s| s.to_string()).unwrap_or_default();
-
-    let role = element.role().map(|s| s.to_string()).unwrap_or_default();
-
     let pid = get_pid(element)?;
 
-    Ok(WindowInfo { pid, title, role })
+    Ok(WindowInfo { pid, title })
 }
 
 /// Get the PID from an AXUIElement
@@ -435,7 +420,11 @@ fn read_bundle_icon_name(bundle_path: &str) -> Option<String> {
     use std::process::Command;
 
     let output = Command::new("defaults")
-        .args(["read", &format!("{bundle_path}/Contents/Info"), "CFBundleIconFile"])
+        .args([
+            "read",
+            &format!("{bundle_path}/Contents/Info"),
+            "CFBundleIconFile",
+        ])
         .output()
         .ok()?;
     if !output.status.success() {
@@ -589,7 +578,6 @@ pub struct WindowRect {
     pub y: f64,
     pub width: f64,
     pub height: f64,
-    pub element: AXUIElement,
     pub pid: i32,
     pub window_id: Option<u32>,
 }
@@ -627,7 +615,6 @@ pub fn get_window_rect(element: &AXUIElement) -> Result<WindowRect, PixieError>
         y: rect.origin.y,
         width: rect.size.width,
         height: rect.size.height,
-        element: element.clone(),
         pid,
         window_id,
     })
@@ -850,7 +837,7 @@ fn get_dict_f64(dict: &CFDictionary, key: &str) -> f64 {
     let key = CFString::new(key);
     unsafe {
         let mut value: *const std::ffi::c_void = std::ptr::null();
-        let key_ptr = key.as_CFTypeRef() as *const std::ffi::c_void;
+        let key_ptr = key.as_CFTypeRef();
         if core_foundation::dictionary::CFDictionaryGetValueIfPresent(
             dict.as_concrete_TypeRef(),
             key_ptr,
@@ -920,11 +907,6 @@ pub fn get_screens() -> Result<Vec<Screen>, PixieError> {
     Ok(screens)
 }
 
-/// Get all visible windows on a specific monitor
-pub fn get_windows_on_monitor(screen: &Screen) -> Result<Vec<WindowEntry>, PixieError> {
-    get_picker_windows(Some(screen))
-}
-
 /// Get all windows used by the picker (including off-screen/minimized)
 pub fn get_all_windows() -> Result<Vec<WindowEntry>, PixieError> {
     get_picker_windows(None)
@@ -1085,7 +1067,9 @@ fn get_picker_windows(screen: Option<&Screen>) -> Result<Vec<WindowEntry>, Pixie
     Ok(windows)
 }
 
-fn get_window_titles_for_pid(pid: i32) -> Result<std::collections::HashMap<u32, String>, PixieError> {
+fn get_window_titles_for_pid(
+    pid: i32,
+) -> Result<std::collections::HashMap<u32, String>, PixieError> {
     let app_element = AXUIElement::application(pid);
 
     let windows = app_element
@@ -1097,7 +1081,10 @@ fn get_window_titles_for_pid(pid: i32) -> Result<std::collections::HashMap<u32,
         if let Some(win) = windows.get(i) {
             let win = win.clone();
             if let Ok(win_id) = get_window_id(&win) {
-                titles.insert(win_id, win.title().map(|s| s.to_string()).unwrap_or_default());
+                titles.insert(
+                    win_id,
+                    win.title().map(|s| s.to_string()).unwrap_or_default(),
+                );
             }
         }
     }
@@ -1320,23 +1307,6 @@ pub fn toggle_fullscreen(element: &AXUIElement) -> Result<(), PixieError> {
     Ok(())
 }
 
-pub fn center_window(element: &AXUIElement) -> Result<(), PixieError> {
-    let window_rect = get_window_rect(element)?;
-    let screen = get_screen_for_window(&window_rect)?;
-
-    let menu_bar_height = if screen.is_main { 25.0 } else { 0.0 };
-
-    let available_x = screen.x;
-    let available_y = screen.y + menu_bar_height;
-    let available_width = screen.width;
-    let available_height = screen.height - menu_bar_height;
-
-    let new_x = available_x + (available_width - window_rect.width) / 2.0;
-    let new_y = available_y + (available_height - window_rect.height) / 2.0;
-
-    set_window_rect(element, new_x, new_y, window_rect.width, window_rect.height)
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MonitorDirection {
     Left,

src/accessibility.rs

@@ -495,6 +495,19 @@ fn parse_key_code(s: &str) -> Result<KeyCode> {
         if c.is_ascii_digit() {
             return digit_to_code(c);
         }
+        return match c {
+            '=' => Ok(KeyCode::Equal),
+            '-' => Ok(KeyCode::Minus),
+            '[' => Ok(KeyCode::BracketLeft),
+            ']' => Ok(KeyCode::BracketRight),
+            '\\' => Ok(KeyCode::Backslash),
+            ';' => Ok(KeyCode::Semicolon),
+            '\'' => Ok(KeyCode::Quote),
+            ',' => Ok(KeyCode::Comma),
+            '.' => Ok(KeyCode::Period),
+            '/' => Ok(KeyCode::Slash),
+            _ => Err(PixieError::Config(format!("Unknown key: {}", s))),
+        };
     }
 
     if s.starts_with('f') || s.starts_with('F') {
@@ -586,7 +599,7 @@ const LAUNCH_AGENT_PLIST: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
     <string>com.pixie</string>
     <key>ProgramArguments</key>
     <array>
-        <string>/Applications/Pixie.app/Contents/MacOS/Pixie</string>
+        <string>/Applications/Pixie.app/Contents/MacOS/pixie</string>
         <string>--headless</string>
     </array>
     <key>RunAtLoad</key>

src/config.rs

@@ -2,6 +2,7 @@
 
 use thiserror::Error;
 
+#[allow(dead_code)]
 #[derive(Error, Debug)]
 pub enum PixieError {
     #[error("Accessibility API error: {0}")]

src/error.rs

@@ -1,5 +1,5 @@
-use core_foundation::runloop::{CFRunLoop, kCFRunLoopCommonModes};
 use core_foundation::base::TCFType;
+use core_foundation::runloop::{CFRunLoop, kCFRunLoopCommonModes};
 use core_graphics::event::{
     CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
     CGEventType, EventField,
@@ -17,7 +17,6 @@ static PICKER_REPEAT_COUNTER: AtomicU8 = AtomicU8::new(0);
 #[derive(Debug, Clone)]
 pub enum EventTapAction {
     LeaderPressed,
-    LeaderReleased,
     KeyPressed(i64, bool),
     ActionTriggered(Action),
     ArrowPressed(crate::accessibility::Direction),
@@ -159,8 +158,9 @@ impl EventHandler {
                                 | PickerInput::SelectUp
                                 | PickerInput::SearchChar('j')
                                 | PickerInput::SearchChar('k') => {
-                                    let repeat = PICKER_REPEAT_COUNTER.fetch_add(1, Ordering::Relaxed);
-                                    if repeat % 2 != 0 {
+                                    let repeat =
+                                        PICKER_REPEAT_COUNTER.fetch_add(1, Ordering::Relaxed);
+                                    if !repeat.is_multiple_of(2) {
                                         event.set_type(CGEventType::Null);
                                         return;
                                     }

src/event_tap.rs

@@ -25,6 +25,7 @@ pub struct LeaderModeController {
 }
 
 impl LeaderModeController {
+    #[allow(dead_code)]
     pub fn new() -> Result<Self> {
         Self::with_timeout(Duration::from_secs(2))
     }
@@ -74,6 +75,7 @@ impl LeaderModeController {
         let _ = self.event_sender.send(event);
     }
 
+    #[allow(dead_code)]
     pub fn cancel(&self) {
         if self.is_listening.swap(false, Ordering::SeqCst) {
             let _ = self.event_sender.send(LeaderModeEvent::Cancelled);
@@ -94,6 +96,7 @@ impl LeaderModeController {
             .send(LeaderModeEvent::FocusDirection(direction));
     }
 
+    #[allow(dead_code)]
     pub fn send_action(&self, action: Action) {
         let _ = self
             .event_sender
@@ -104,6 +107,7 @@ impl LeaderModeController {
         self.event_receiver.clone()
     }
 
+    #[allow(dead_code)]
     pub fn is_listening(&self) -> bool {
         self.is_listening.load(Ordering::SeqCst)
     }

src/leader_mode.rs

@@ -34,7 +34,7 @@ use event_tap::EventTapAction;
 use leader_mode::{LeaderModeController, LeaderModeEvent};
 use window::WindowManager;
 
-struct WindowManagerState(pub Arc<WindowManager>);
+struct WindowManagerState;
 impl gpui::Global for WindowManagerState {}
 
 /// Pixie - macOS Window Focusing Tool
@@ -75,45 +75,57 @@ static RUNNING: AtomicBool = AtomicBool::new(true);
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let args = Args::parse();
+    let args = Args::parse_from(std::env::args().filter(|arg| !arg.starts_with("-psn_")));
 
     let is_from_terminal = std::env::var("TERM_PROGRAM").is_ok();
     if is_from_terminal {
         println!("Note: Running from Terminal. If permissions don't work,");
         println!("      try running as: open /Applications/Pixie.app\n");
     }
 
-    let mut attempts = 0;
-    loop {
-        match accessibility::test_api_access() {
-            Ok(()) => {
-                tracing::info!("Accessibility API working");
-                break;
-            }
-            Err(e) => {
-                if attempts == 0 {
-                    println!("\n⚠️  Accessibility API not available: {}", e);
-                    println!("\nSteps to fix:");
-                    println!("1. System Preferences → Privacy & Security → Accessibility");
-                    println!("2. Make sure Pixie.app is in the list AND CHECKED");
-                    println!("3. If running from Terminal, also add Terminal.app");
-                    println!("\nOpening System Preferences...\n");
-
-                    accessibility::request_accessibility_permissions();
-
-                    let _ = std::process::Command::new("open")
-                        .arg("x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility")
-                        .spawn();
+    if is_from_terminal {
+        let mut attempts = 0;
+        loop {
+            match accessibility::test_api_access() {
+                Ok(()) => {
+                    tracing::info!("Accessibility API working");
+                    break;
                 }
+                Err(e) => {
+                    if attempts == 0 {
+                        println!("\n⚠️  Accessibility API not available: {}", e);
+                        println!("\nSteps to fix:");
+                        println!("1. System Preferences → Privacy & Security → Accessibility");
+                        println!("2. Make sure Pixie.app is in the list AND CHECKED");
+                        println!("3. If running from Terminal, also add Terminal.app");
+                        println!("\nOpening System Preferences...\n");
+
+                        accessibility::request_accessibility_permissions();
+
+                        let _ = std::process::Command::new("open")
+                            .arg("x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility")
+                            .spawn();
+                    }
 
-                attempts += 1;
-                if attempts % 5 == 0 {
-                    println!("Still waiting for permissions... (attempt {})", attempts);
-                }
+                    attempts += 1;
+                    if attempts % 5 == 0 {
+                        println!("Still waiting for permissions... (attempt {})", attempts);
+                    }
 
-                std::thread::sleep(std::time::Duration::from_secs(1));
+                    std::thread::sleep(std::time::Duration::from_secs(1));
+                }
             }
         }
+    } else if let Err(e) = accessibility::test_api_access() {
+        tracing::warn!(
+            "Accessibility API not ready at app launch: {}. Prompting and exiting for relaunch.",
+            e
+        );
+        accessibility::request_accessibility_permissions();
+        let _ = std::process::Command::new("open")
+            .arg("x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility")
+            .spawn();
+        return Ok(());
     }
 
     let window_manager = Arc::new(WindowManager::new()?);
@@ -300,7 +312,9 @@ fn apply_autostart_setting(enabled: bool) {
     }
 }
 
-fn runtime_bindings(cfg: &config::Config) -> (
+fn runtime_bindings(
+    cfg: &config::Config,
+) -> (
     config::Modifiers,
     config::KeyCode,
     Vec<config::KeybindEntry>,
@@ -439,7 +453,7 @@ fn run_daemon(window_manager: Arc<WindowManager>, headless: bool) -> Result<()>
 
             ui::init(cx);
 
-            cx.set_global(WindowManagerState(wm_for_events.clone()));
+            cx.set_global(WindowManagerState);
 
             let menu_bar_controller = if menubar_enabled {
                 match menu_bar::MenuBarController::new(
@@ -484,7 +498,6 @@ fn run_daemon(window_manager: Arc<WindowManager>, headless: bool) -> Result<()>
                                     notification::notify("Pixie", "Listening...");
                                     let _ = ui_sender.send(UiAction::MenuBarSetActive(true));
                                 }
-                                EventTapAction::LeaderReleased => {}
                                 EventTapAction::KeyPressed(keycode, has_shift) => {
                                     if let Some(letter) = keycode_to_letter(keycode) {
                                         controller.handle_key(letter, has_shift);
@@ -775,7 +788,6 @@ fn run_headless_only(
                         notification::notify("Pixie", "Listening...");
                         println!("Listening...");
                     }
-                    EventTapAction::LeaderReleased => {}
                     EventTapAction::KeyPressed(keycode, has_shift) => {
                         if let Some(letter) = keycode_to_letter(keycode) {
                             controller_for_event.handle_key(letter, has_shift);