@@ -47,8 +47,6 @@ features = ["native-tls", "socks", "gzip", "deflate"]
 winreg = "^0.55.0"
 
 [target.'cfg(target_os = "macos")'.dependencies]
-objc2 = "^0.6"
-once_cell = "1"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-cli = "2"
 
@@ -382,6 +382,7 @@ pub struct Ipc {
     stop_signal: Option<oneshot::Sender<()>>,
     args_sem: Arc<Semaphore>,
     args_lock: Option<OwnedSemaphorePermit>,
+    pending: Vec<String>,
 }
 
 impl Ipc {
@@ -392,9 +393,19 @@ impl Ipc {
             stop_signal: Default::default(),
             args_sem: Semaphore::new(1).into(),
             args_lock: None,
+            pending: Vec::new(),
         }
     }
 
+    #[cfg(target_os = "macos")]
+    pub fn push_pending(&mut self, uris: Vec<String>) {
+        self.pending.extend(uris);
+    }
+
+    pub fn take_pending(&mut self) -> Vec<String> {
+        std::mem::take(&mut self.pending)
+    }
+
     pub async fn init(&mut self) {
         self.args_lock = self.args_sem.clone().acquire_owned().await.ok();
 
 
@@ -14,159 +14,8 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-// Based on https://github.com/FabianLars/tauri-plugin-deep-link
-
-use std::{
-    io::{ErrorKind, Result},
-    sync::Mutex,
-};
-
-use objc2::{
-    class, define_class,
-    ffi::NSInteger,
-    msg_send,
-    rc::Retained,
-    runtime::{AnyObject, NSObject},
-    sel, ClassType,
-};
-use once_cell::sync::OnceCell;
 use tauri::{menu::{Menu, MenuItem, PredefinedMenuItem, Submenu}, AppHandle};
 
-type THandler = OnceCell<Mutex<Box<dyn FnMut(Vec<String>) + Send + 'static>>>;
-
-// If the Mutex turns out to be a problem, or FnMut turns out to be useless, we can remove the Mutex and turn FnMut into Fn
-static HANDLER: THandler = OnceCell::new();
-
-// keyDirectObject
-const KEY_DIRECT_OBJECT: u32 = 0x2d2d2d2d;
-
-// kInternetEventClass
-const GURL_EVENT_CLASS: u32 = 0x4755524c;
-// kAEGetURL
-const EVENT_GET_URL: u32 = 0x4755524c;
-
-// kCoreEventClass
-const CORE_EVENT_CLASS: u32 = 0x61657674;
-// kAEOpenDocuments
-const EVENT_OPEN_DOCUMENTS: u32 = 0x6F646F63;
-// kAEReopenApplication
-const EVENT_REOPEN_APP: u32 = 0x72617070;
-
-// Adapted from https://github.com/mrmekon/fruitbasket/blob/aad14e400d710d1d46317c0d8c55ff742bfeaadd/src/osx.rs#L848
-fn parse_event(event: *mut AnyObject) -> Vec<String> {
-    if event as u64 == 0u64 {
-        return vec![];
-    }
-    unsafe {
-        let class: u32 = msg_send![event, eventClass];
-        let id: u32 = msg_send![event, eventID];
-
-        match (class, id) {
-            (GURL_EVENT_CLASS, EVENT_GET_URL) => {
-                let url: *mut AnyObject =
-                    msg_send![event, paramDescriptorForKeyword: KEY_DIRECT_OBJECT];
-                let nsstring: *mut AnyObject = msg_send![url, stringValue];
-                let cstr: *const i8 = msg_send![nsstring, UTF8String];
-
-                if !cstr.is_null() {
-                    vec![std::ffi::CStr::from_ptr(cstr).to_string_lossy().to_string()]
-                } else {
-                    vec![]
-                }
-            }
-            (CORE_EVENT_CLASS, EVENT_OPEN_DOCUMENTS) => {
-                let documents: *mut AnyObject =
-                    msg_send![event, paramDescriptorForKeyword: KEY_DIRECT_OBJECT];
-                let count: NSInteger = msg_send![documents, numberOfItems];
-
-                let mut paths = Vec::<String>::new();
-
-                for i in 1..count + 1 {
-                    let path: *mut AnyObject = msg_send![documents, descriptorAtIndex: i];
-                    let nsstring: *mut AnyObject = msg_send![path, stringValue];
-                    let cstr: *const i8 = msg_send![nsstring, UTF8String];
-
-                    if !cstr.is_null() {
-                        let path_str = std::ffi::CStr::from_ptr(cstr).to_string_lossy().to_string();
-                        paths.push(path_str);
-                    }
-                }
-
-                paths
-            }
-            // reopen app event has no useful payload
-            (_, _) => {
-                vec![]
-            }
-        }
-    }
-}
-
-define_class!(
-    #[unsafe(super(NSObject))]
-    #[name = "TauriPluginDeepLinkHandler"]
-    struct Handler;
-
-    impl Handler {
-        #[unsafe(method(handleEvent:withReplyEvent:))]
-        fn handle_event(&self, event: *mut AnyObject, _replace: *const AnyObject) {
-            let s = parse_event(event);
-            let mut cb = HANDLER.get().unwrap().lock().unwrap();
-            cb(s);
-        }
-    }
-);
-
-impl Handler {
-    pub fn new() -> Retained<Self> {
-        let cls = Self::class();
-        unsafe { msg_send![msg_send![cls, alloc], init] }
-    }
-}
-
-// Call this once early in app main() or setup hook
-pub fn set_handler<F: FnMut(Vec<String>) + Send + 'static>(handler: F) -> Result<()> {
-    if HANDLER.set(Mutex::new(Box::new(handler))).is_err() {
-        return Err(std::io::Error::new(
-            ErrorKind::AlreadyExists,
-            "Handler was already set",
-        ));
-    }
-
-    Ok(())
-}
-
-fn listen_apple_event(event_class: u32, event_id: u32) {
-    unsafe {
-        let event_manager: Retained<AnyObject> =
-            msg_send![class!(NSAppleEventManager), sharedAppleEventManager];
-
-        let handler = Handler::new();
-        let handler_boxed = Box::into_raw(Box::new(handler));
-
-        let _: () = msg_send![&event_manager,
-            setEventHandler: &**handler_boxed,
-            andSelector: sel!(handleEvent:withReplyEvent:),
-            forEventClass: event_class,
-            andEventID: event_id];
-    }
-}
-
-// Call this in app setup hook
-pub fn listen_url() {
-    listen_apple_event(GURL_EVENT_CLASS, EVENT_GET_URL);
-}
-
-// Call this after app is initialised
-pub fn listen_open_documents() {
-    listen_apple_event(CORE_EVENT_CLASS, EVENT_OPEN_DOCUMENTS);
-}
-
-// Call this after app is initialised
-pub fn listen_reopen_app() {
-    listen_apple_event(CORE_EVENT_CLASS, EVENT_REOPEN_APP);
-}
-
 pub fn make_menu<R>(app: &AppHandle<R>) -> tauri::Result<Menu<R>>
 where
     R: tauri::Runtime,
 
@@ -45,10 +45,20 @@ struct ListenerHandle(Arc<RwLock<ipc::Ipc>>);
 
 #[cfg(target_os = "macos")]
 fn handle_uris(app: &AppHandle, uris: Vec<String>) {
+    if uris.is_empty() {
+        return;
+    }
     let listener_state: State<ListenerHandle> = app.state();
     let listener_lock = listener_state.0.clone();
     let app_handle = app.clone();
     async_runtime::spawn(async move {
+        {
+            let mut listener = listener_lock.write().await;
+            if !listener.listening {
+                listener.push_pending(uris);
+                return;
+            }
+        }
         let listener = listener_lock.read().await;
         if let Err(e) = listener.send(&uris, app_handle).await {
             println!("Unable to send args to listener: {:?}", e);
@@ -57,16 +67,6 @@ fn handle_uris(app: &AppHandle, uris: Vec<String>) {
 }
 
 fn setup(app: &mut App) -> Result<(), Box<dyn std::error::Error>> {
-    #[cfg(target_os = "macos")]
-    {
-        let app_handle = app.handle().clone();
-        macos::set_handler(move |uris| {
-            handle_uris(&app_handle, uris);
-        })
-        .expect("Unable to set apple event handler");
-        macos::listen_url();
-    }
-
     let mut torrents: Vec<String> = vec![];
     match app.cli().matches() {
         Ok(matches) => {
@@ -75,7 +75,6 @@ fn setup(app: &mut App) -> Result<(), Box<dyn std::error::Error>> {
                 app.handle().exit(0);
                 return Ok(());
             }
-
             if matches.args["torrent"].value.is_array() {
                 torrents = matches.args["torrent"]
                     .value
@@ -129,16 +128,11 @@ fn setup(app: &mut App) -> Result<(), Box<dyn std::error::Error>> {
 
         let app_clone = app.clone();
         async_runtime::spawn(async move {
-            let listener = listener_lock.read().await;
+            let mut listener = listener_lock.write().await;
+            torrents.extend(listener.take_pending());
             if let Err(e) = listener.send(&torrents, app_clone).await {
                 println!("Unable to send args to listener: {e}");
             }
-
-            #[cfg(target_os = "macos")]
-            {
-                macos::listen_open_documents();
-                macos::listen_reopen_app();
-            }
         });
 
         let app_clone = app.clone();
@@ -192,6 +186,7 @@ fn http_clients() -> HttpClients {
 
 fn main() {
     let context = tauri::generate_context!();
+    let ipc = ipc::Ipc::new();
 
     let app_builder = tauri::Builder::default()
         .plugin(tauri_plugin_cli::init())
@@ -217,7 +212,7 @@ fn main() {
             commands::save_text_file,
             commands::load_text_file,
         ])
-        .manage(ListenerHandle(Arc::new(RwLock::new(ipc::Ipc::new()))))
+        .manage(ListenerHandle(Arc::new(RwLock::new(ipc))))
         .manage(TorrentCacheHandle::default())
         .manage(PollerHandle::default())
         .manage(MmdbReaderHandle::default())
@@ -228,19 +223,26 @@ fn main() {
     #[cfg(target_os = "macos")]
     let app_builder = app_builder
         .menu(macos::make_menu)
-        .on_menu_event(|app, event| match event.id().as_ref() {
-            "appquit" => {
-                tray::exit(app.clone());
-            }
-            _ => {}
+        .on_menu_event(|app, event| if event.id().as_ref() == "appquit" {
+            tray::exit(app.clone());
         });
 
     let app = app_builder
         .build(context)
         .expect("error while running tauri application");
 
     #[allow(clippy::single_match)]
-    app.run(|app_handle, event| match event {
+    app.run(move |app_handle, event| match event {
+        #[cfg(target_os = "macos")]
+        tauri::RunEvent::Opened { urls } => {
+            let urls: Vec<String> = urls.into_iter().map(|url| url.to_string()).collect();
+            handle_uris(app_handle, urls);
+        }
+        #[cfg(target_os = "macos")]
+        tauri::RunEvent::Reopen { has_visible_windows, .. }
+        if !has_visible_windows => {
+            tray::toggle_main_window(app_handle, app_handle.get_webview_window("main"));
+        }
         tauri::RunEvent::ExitRequested { api, .. } => {
             api.prevent_exit();
             tray::set_tray_showhide_text(app_handle, "Show");
 
@@ -96,12 +96,12 @@ const ServerModals = React.forwardRef<ModalCallbacks, ServerModalsProps>(functio
     const [addQueue, setAddQueue] = useState<Array<string | File>>(urlAddParam != null ? [urlAddParam] : []);
 
     const enqueue = useCallback((paths: string[] | File[]) => {
-        setAddQueue([...addQueue, ...paths]);
+        setAddQueue((queue) => [...queue, ...paths]);
         void appWindow.show();
         void appWindow.unminimize();
         void appWindow.setFocus();
         void appWindow.emit("window-shown");
-    }, [addQueue]);
+    }, []);
 
     useEffect(() => {
         if (TAURI) {