Fix deep linking / file open on mac (#2314)

* Fix deep linking / file open on mac

* Update deep linking

* fix build

* fix build again

* update workdir

* try again

* update conf path

* try old conf

* use in house tauri

* move away from tauri GH act

* add rpm support

* Fix updater key

* Fix signing key pass

* fix ubuntu deps

* Fix macos artifacts

apps/app/src/api/utils.rs

@@ -137,5 +137,6 @@ pub async fn get_opening_command() -> Result<Option<CommandPayload>> {
 // helper function called when redirected by a weblink (ie: modrith://do-something) or when redirected by a .mrpack file (in which case its a filepath)
 // We hijack the deep link library (which also contains functionality for instance-checking)
 pub async fn handle_command(command: String) -> Result<()> {
+    tracing::info!("handle command: {command}");
     Ok(theseus::handler::parse_and_emit_command(&command).await?)
 }

apps/app/src/macos/deep_link.rs

@@ -1,6 +1,28 @@
 use std::sync::Arc;
+use tauri::{Manager, Runtime};
 use tokio::sync::Mutex;
 
+#[derive(Debug, Clone)]
 pub struct InitialPayload {
     pub payload: Arc<Mutex<Option<String>>>,
 }
+
+pub fn get_or_init_payload<R: Runtime, M: Manager<R>>(
+    manager: &M,
+) -> InitialPayload {
+    let initial_payload = manager.try_state::<InitialPayload>();
+    let mtx = if let Some(initial_payload) = initial_payload {
+        initial_payload.inner().clone()
+    } else {
+        tracing::info!("No initial payload found, creating new");
+        let payload = InitialPayload {
+            payload: Arc::new(Mutex::new(None)),
+        };
+
+        manager.manage(payload.clone());
+
+        payload
+    };
+
+    mtx
+}

apps/app/src/main.rs

@@ -114,27 +114,29 @@ fn main() {
         .setup(|app| {
             #[cfg(target_os = "macos")]
             {
-                use macos::deep_link::InitialPayload;
-                let mtx = std::sync::Arc::new(tokio::sync::Mutex::new(None));
+                let payload = macos::deep_link::get_or_init_payload(app);
 
-                app.manage(InitialPayload {
-                    payload: mtx.clone(),
-                });
-
-                let mtx_copy = mtx.clone();
+                let mtx_copy = payload.payload.clone();
                 app.listen("deep-link://new-url", move |url| {
                     let mtx_copy_copy = mtx_copy.clone();
                     let request = url.payload().to_owned();
 
+                    let actual_request =
+                        serde_json::from_str::<Vec<String>>(&request)
+                            .ok()
+                            .map(|mut x| x.remove(0))
+                            .unwrap_or(request);
+
                     tauri::async_runtime::spawn(async move {
-                        tracing::info!("Handling deep link {request}");
+                        tracing::info!("Handling deep link {actual_request}");
 
                         let mut payload = mtx_copy_copy.lock().await;
                         if payload.is_none() {
-                            *payload = Some(request.clone());
+                            *payload = Some(actual_request.clone());
                         }
 
-                        let _ = api::utils::handle_command(request).await;
+                        let _ =
+                            api::utils::handle_command(actual_request).await;
                     });
                 });
             };
@@ -206,11 +208,11 @@ fn main() {
                         .next();
 
                     if let Some(file) = file {
-                        use macos::deep_link::InitialPayload;
-                        let initial_payload = app.state::<InitialPayload>();
-                        let request = file.to_string_lossy().to_string();
+                        let payload =
+                            macos::deep_link::get_or_init_payload(app);
 
-                        let mtx_copy = initial_payload.payload.clone();
+                        let mtx_copy = payload.payload.clone();
+                        let request = file.to_string_lossy().to_string();
                         tauri::async_runtime::spawn(async move {
                             let mut payload = mtx_copy.lock().await;
                             if payload.is_none() {