0.8.0 beta fixes (#2154)

* initial fixes

* 0.8.0 beta fixes

* run actions

* run fmt

* Fix windows build

* Add purge cache opt

* add must revalidate to project req

* lint + clippy

* fix processes, open folder

* Update migrator to use old launcher cache for perf

* fix empty dirs not moving

* fix lint + create natives dir if not exist

* fix large request batches

* finish

* Fix deep linking on mac

* fix comp err

* fix comp err (2)

---------

Signed-off-by: Geometrically <18202329+Geometrically@users.noreply.github.com>

apps/app/src/main.rs

@@ -16,12 +16,25 @@ mod macos;
 #[tracing::instrument(skip_all)]
 #[tauri::command]
 async fn initialize_state(app: tauri::AppHandle) -> api::Result<()> {
-    theseus::EventState::init(app).await?;
+    theseus::EventState::init(app.clone()).await?;
     State::init().await?;
 
+    let state = State::get().await?;
+    app.asset_protocol_scope()
+        .allow_directory(state.directories.caches_dir(), true)?;
+
     Ok(())
 }
 
+// Should be call once Vue has mounted the app
+#[tracing::instrument(skip_all)]
+#[tauri::command]
+fn show_window(app: tauri::AppHandle) {
+    let win = app.get_window("main").unwrap();
+    win.show().unwrap();
+    win.set_focus().unwrap();
+}
+
 #[tauri::command]
 fn is_dev() -> bool {
     cfg!(debug_assertions)
@@ -76,41 +89,84 @@ fn main() {
         }))
         .plugin(tauri_plugin_window_state::Builder::default().build())
         .setup(|app| {
-            // Register deep link handler, allowing reading of modrinth:// links
-            if let Err(e) = tauri_plugin_deep_link::register(
+            #[cfg(target_os = "macos")]
+            let res = {
+                use macos::deep_link::InitialPayload;
+                let mtx = std::sync::Arc::new(tokio::sync::Mutex::new(None));
+
+                app.manage(InitialPayload {
+                    payload: mtx.clone(),
+                });
+
+                let mtx_copy = mtx.clone();
+                macos::delegate::register_open_file(move |filename| {
+                    let mtx_copy = mtx_copy.clone();
+
+                    tauri::async_runtime::spawn(async move {
+                        tracing::info!("Handling file open {filename}");
+
+                        let mut payload = mtx_copy.lock().await;
+                        if payload.is_none() {
+                            *payload = Some(filename.clone());
+                        }
+
+                        let _ = api::utils::handle_command(filename).await;
+                    });
+                })
+                .unwrap();
+
+                let mtx_copy = mtx.clone();
+                tauri_plugin_deep_link::register(
+                    "modrinth",
+                    move |request: String| {
+                        let mtx_copy = mtx_copy.clone();
+
+                        tauri::async_runtime::spawn(async move {
+                            tracing::info!("Handling deep link {request}");
+
+                            let mut payload = mtx_copy.lock().await;
+                            if payload.is_none() {
+                                *payload = Some(request.clone());
+                            }
+
+                            let _ = api::utils::handle_command(request).await;
+                        });
+                    },
+                )
+            };
+
+            #[cfg(not(target_os = "macos"))]
+            let res = tauri_plugin_deep_link::register(
                 "modrinth",
                 |request: String| {
+                    tracing::info!("Handling deep link {request}");
                     tauri::async_runtime::spawn(api::utils::handle_command(
                         request,
                     ));
                 },
-            ) {
-                // Allow it to fail- see https://github.com/FabianLars/tauri-plugin-deep-link/issues/19
+            );
+
+            if let Err(e) = res {
                 tracing::error!("Error registering deep link handler: {}", e);
             }
 
-            let win = app.get_window("main").unwrap();
-            #[cfg(not(target_os = "linux"))]
-            {
-                use window_shadows::set_shadow;
-                set_shadow(&win, true).unwrap();
-            }
-            #[cfg(target_os = "macos")]
-            {
-                use macos::window_ext::WindowExt;
-                win.set_transparent_titlebar(true);
-                win.position_traffic_lights(9.0, 16.0);
+            if let Some(window) = app.get_window("main") {
+                // Hide window to prevent white flash on startup
+                window.hide().unwrap();
 
-                macos::delegate::register_open_file(|filename| {
-                    tauri::async_runtime::spawn(api::utils::handle_command(
-                        filename,
-                    ));
-                })
-                .unwrap();
-            }
+                #[cfg(not(target_os = "linux"))]
+                {
+                    use window_shadows::set_shadow;
+                    set_shadow(&window, true).unwrap();
+                }
 
-            // Show app now that we are setup
-            win.show().unwrap();
+                #[cfg(target_os = "macos")]
+                {
+                    use macos::window_ext::WindowExt;
+                    window.set_transparent_titlebar(true);
+                    window.position_traffic_lights(9.0, 16.0);
+                }
+            }
 
             Ok(())
         });
@@ -148,6 +204,7 @@ fn main() {
             toggle_decorations,
             api::auth::auth_login,
             api::mr_auth::modrinth_auth_login,
+            show_window,
         ]);
 
     builder