feat: distinguish normal instances and local scene development instances for deep links (#141)

* ignore lsd instances

* recognize local-scene in deeplink;

* apply clippy

* use cmd_args to determine if local_scene

Author: NickKhalow

core/Cargo.lock

@@ -32,6 +32,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "stream"] }
 regex = "1.11.1"
+url = "2.5.4"
 anyhow = "1.0.97"
 
 futures-util = "0.3.14"

core/Cargo.toml

@@ -13,6 +13,7 @@ const ARG_OPEN_DEEPLINK_IN_NEW_INSTANCE: &str = "open-deeplink-in-new-instance";
 const ARG_ALWAYS_TRIGGER_UPDATER: &str = "always-trigger-updater";
 const ARG_NEVER_TRIGGER_UPDATER: &str = "never-trigger-updater";
 const ARG_USE_UPDATER_URL: &str = "use-updater-url";
+const ARG_LOCAL_SCENE: &str = "local-scene";
 
 #[derive(Debug)]
 pub enum LauncherEnvironment {
@@ -32,6 +33,9 @@ pub struct Args {
     pub always_trigger_updater: bool,
     pub never_trigger_updater: bool,
     pub use_updater_url: Option<String>,
+
+    // used by the client
+    pub local_scene: bool,
 }
 
 impl Args {
@@ -47,6 +51,7 @@ impl Args {
                 .use_updater_url
                 .clone()
                 .or_else(|| other.use_updater_url.clone()),
+            local_scene: self.local_scene || other.local_scene,
         }
     }
 
@@ -62,6 +67,7 @@ impl Args {
             always_trigger_updater: Self::has_flag(ARG_ALWAYS_TRIGGER_UPDATER, &vector),
             never_trigger_updater: Self::has_flag(ARG_NEVER_TRIGGER_UPDATER, &vector),
             use_updater_url: Self::value_by_flag(ARG_USE_UPDATER_URL, &vector),
+            local_scene: Self::has_flag(ARG_LOCAL_SCENE, &vector),
         }
     }
 
@@ -206,6 +212,7 @@ mod tests {
             always_trigger_updater: true,
             never_trigger_updater: false,
             use_updater_url: Some("https://one.com".into()),
+            local_scene: false,
         };
 
         let b = Args {
@@ -214,6 +221,7 @@ mod tests {
             always_trigger_updater: false,
             never_trigger_updater: true,
             use_updater_url: Some("https://two.com".into()),
+            local_scene: false,
         };
 
         let merged = a.merge_with(&b);
@@ -222,6 +230,7 @@ mod tests {
         assert!(merged.open_deeplink_in_new_instance);
         assert!(merged.always_trigger_updater);
         assert!(merged.never_trigger_updater);
+        assert!(!merged.local_scene);
         // Should keep first if present
         assert_eq!(merged.use_updater_url.as_deref(), Some("https://one.com"));
     }

core/src/environment.rs

@@ -425,9 +425,13 @@ impl WorkflowStep<LaunchFlowState, ()> for AppLaunchStep {
 
         match self.protocol.value() {
             Some(deeplink) => {
-                let open_new_instance = AppEnvironment::cmd_args().open_deeplink_in_new_instance;
+                let args = AppEnvironment::cmd_args();
+
+                let open_new_instance = args.open_deeplink_in_new_instance;
                 let any_is_running = self.is_any_instance_running().await?;
-                if !open_new_instance && any_is_running {
+                let is_local_scene = deeplink.has_true_value("local-scene") || args.local_scene;
+
+                if !open_new_instance && any_is_running && !is_local_scene {
                     channel.send(Status::State {
                         step: Step::DeeplinkOpening,
                     })?;

core/src/flow.rs

@@ -1,5 +1,7 @@
+use std::collections::HashMap;
 use std::result::Result;
 use std::sync::Mutex;
+use url::form_urlencoded;
 
 use log::{error, warn};
 
@@ -14,23 +16,63 @@ pub enum DeepLinkCreateError {
 }
 
 #[derive(Clone)]
-pub struct DeepLink(String);
+pub struct DeepLink {
+    original: String,
+    args: HashMap<String, String>,
+}
 
 impl DeepLink {
     fn new(value: String) -> Result<Self, DeepLinkCreateError> {
         if value.starts_with(PROTOCOL_PREFIX) {
-            Ok(Self(value))
+            let args = Self::parsed_args(value.as_str());
+            let result = Self {
+                original: value,
+                args,
+            };
+            Ok(result)
         } else {
             Err(DeepLinkCreateError::WrongPrefix {
                 original_content: value,
             })
         }
     }
+
+    fn parsed_args(value: &str) -> HashMap<String, String> {
+        let parts: Vec<&str> = value.splitn(2, "://").collect();
+
+        match parts.get(1) {
+            Some(query) => {
+                let scheme = parts.first().unwrap_or(&"unknown");
+                log::info!("Deeplink scheme: {}", scheme);
+
+                let parsed = form_urlencoded::parse(query.as_bytes());
+                let mut map: HashMap<String, String> = HashMap::new();
+
+                for (key, value) in parsed {
+                    map.insert(key.into_owned(), value.into_owned());
+                }
+
+                map
+            }
+            None => {
+                log::info!("Cannot get query from: {}", value);
+                HashMap::new()
+            }
+        }
+    }
+
+    pub fn has_true_value(&self, key: &str) -> bool {
+        if let Some(value) = self.args.get(key) {
+            value == "true"
+        } else {
+            false
+        }
+    }
 }
 
 impl From<DeepLink> for String {
     fn from(deeplink: DeepLink) -> Self {
-        deeplink.0
+        deeplink.original
     }
 }