fix(platform): properly strip responder sub-domain prefixes during import when necessary

Author: azasypkin

src/server.rs

@@ -260,6 +260,10 @@ pub async fn run(config: Config, http_port: u16) -> Result<(), anyhow::Error> {
                                         "/{user_handle}/{responder_path:.*}",
                                         web::route().to(handlers::webhooks_responders),
                                     )
+                                    .route(
+                                        "/{user_handle}",
+                                        web::route().to(handlers::webhooks_responders),
+                                    )
                                     .route("", web::route().to(handlers::webhooks_responders)),
                             ),
                     )

src/server/handlers/webhooks_responders.rs

@@ -88,6 +88,8 @@ pub async fn webhooks_responders(
     // Extract the responder path either from path or from the request headers.
     let mut responder_path = if let Some(responder_path) = path_params.responder_path {
         format!("/{responder_path}")
+    } else if path_params.user_handle.is_some() {
+        "/".to_string()
     } else {
         let replaced_path = request
             .headers()

src/users/user_data/import.rs

@@ -3,6 +3,7 @@ mod detect_deletions;
 mod detect_duplicates;
 mod file;
 mod importers;
+mod normalize_responder;
 mod params;
 mod resolve_name;
 mod results;
@@ -36,6 +37,7 @@ use importers::{
     responders::import_responders, scripts::import_scripts, secrets::import_secrets,
     tags::import_tags, trackers::import_trackers,
 };
+use normalize_responder::should_strip_subdomain_prefixes;
 use results::{
     ApplyDeleteItem, ApplyDeleteSummary, ImportEntitySummary, ImportPreviewSummary,
     ImportResultsSummary, ImportSettingsSummary, UserDataImportPreview, UserDataImportResult,
@@ -238,7 +240,11 @@ pub async fn generate_import_preview<DR: DnsResolver, ET: EmailTransport>(
     let existing_responder_refs: Vec<&Responder> = existing_responders.iter().collect();
     let responders_summary = ImportEntitySummary {
         total: import_responder_refs.len(),
-        conflicts: detect_responder_conflicts(&import_responder_refs, &existing_responder_refs),
+        conflicts: detect_responder_conflicts(
+            &import_responder_refs,
+            &existing_responder_refs,
+            should_strip_subdomain_prefixes(&api.config, user),
+        ),
     };
     let existing_responder_pairs: Vec<(Uuid, String)> = existing_responders
         .iter()

src/users/user_data/import/detect_conflicts.rs

@@ -1,5 +1,5 @@
 use super::results::ImportConflict;
-use crate::utils::webhooks::{Responder, ResponderMethod};
+use crate::utils::webhooks::{Responder, ResponderLocation, ResponderMethod};
 use std::collections::{HashMap, HashSet};
 use uuid::Uuid;
 
@@ -32,16 +32,37 @@ fn methods_conflict(a: ResponderMethod, b: ResponderMethod) -> bool {
     a == b || a == ResponderMethod::Any || b == ResponderMethod::Any
 }
 
+/// Returns the string key used for location-based conflict comparison.
+/// When `strip_subdomain_prefix` is true and the location carries a prefix, the prefix
+/// portion is omitted so that imported responders with unsupported prefixes are compared
+/// as if they had no prefix.
+fn location_key(location: &ResponderLocation, strip_subdomain_prefix: bool) -> String {
+    if strip_subdomain_prefix && location.subdomain_prefix.is_some() {
+        format!(
+            ":{}:{}",
+            location.path_type,
+            location.path.to_ascii_lowercase()
+        )
+    } else {
+        location.to_string()
+    }
+}
+
 /// Detects responder conflicts by name **and** location+method.
 ///
 /// A conflict is produced when an imported responder matches an existing one by:
 /// - Same name, OR
 /// - Same location AND conflicting method (equal, or either is `Any`)
 ///
 /// If both criteria match the **same** existing responder, only one conflict is emitted.
+///
+/// When `strip_subdomain_prefix` is true, subdomain prefixes on **imported** responder
+/// locations are ignored during comparison (existing responders never carry unsupported
+/// prefixes since the server validated them at creation time).
 pub fn detect_responder_conflicts(
     import_items: &[&Responder],
     existing_items: &[&Responder],
+    strip_subdomain_prefix: bool,
 ) -> Vec<ImportConflict> {
     let existing_by_name: HashMap<&str, &Responder> = existing_items
         .iter()
@@ -51,26 +72,27 @@ pub fn detect_responder_conflicts(
     // Index existing responders by location string so we only check
     // location+method conflicts against responders that share the same path,
     // instead of scanning the entire existing list for every import.
+    // Existing responders are never stripped - they were validated at creation time.
     let mut existing_by_location: HashMap<String, Vec<&Responder>> =
         HashMap::with_capacity(existing_items.len());
     for &r in existing_items {
         existing_by_location
-            .entry(r.location.to_string())
+            .entry(location_key(&r.location, false))
             .or_default()
             .push(r);
     }
 
     let mut conflicts = Vec::new();
     for &imported in import_items {
         let mut seen_ids: HashSet<Uuid> = HashSet::new();
-        let import_loc = imported.location.to_string();
+        let import_loc = location_key(&imported.location, strip_subdomain_prefix);
 
         // Check name conflict.
         if let Some(existing) = existing_by_name.get(imported.name.as_str()) {
             seen_ids.insert(existing.id);
             // If the same existing responder also conflicts on location+method,
             // renaming won't help - the location+method collision remains.
-            let also_location_conflict = existing.location.to_string() == import_loc
+            let also_location_conflict = location_key(&existing.location, false) == import_loc
                 && methods_conflict(imported.method, existing.method);
             conflicts.push(ImportConflict {
                 source_id: imported.id,
@@ -127,13 +149,23 @@ mod tests {
     }
 
     fn make_responder(id: u128, name: &str, path: &str, method: ResponderMethod) -> Responder {
+        make_responder_with_prefix(id, name, path, method, None)
+    }
+
+    fn make_responder_with_prefix(
+        id: u128,
+        name: &str,
+        path: &str,
+        method: ResponderMethod,
+        subdomain_prefix: Option<&str>,
+    ) -> Responder {
         Responder {
             id: Uuid::from_u128(id),
             name: name.to_string(),
             location: ResponderLocation {
                 path_type: ResponderPathType::Exact,
                 path: path.to_string(),
-                subdomain_prefix: None,
+                subdomain_prefix: subdomain_prefix.map(str::to_string),
             },
             method,
             enabled: true,
@@ -155,7 +187,7 @@ mod tests {
     fn responder_conflicts_finds_location_method_match() {
         let imported = make_responder(1, "new-name", "/test", ResponderMethod::Get);
         let existing = make_responder(100, "old-name", "/test", ResponderMethod::Get);
-        let conflicts = detect_responder_conflicts(&[&imported], &[&existing]);
+        let conflicts = detect_responder_conflicts(&[&imported], &[&existing], false);
         assert_eq!(conflicts.len(), 1);
         assert_eq!(conflicts[0].source_id, Uuid::from_u128(1));
         assert_eq!(conflicts[0].existing_id, Uuid::from_u128(100));
@@ -166,13 +198,13 @@ mod tests {
     fn responder_conflicts_any_method_conflicts_with_specific() {
         let imported = make_responder(1, "new-name", "/test", ResponderMethod::Any);
         let existing = make_responder(100, "old-name", "/test", ResponderMethod::Get);
-        let conflicts = detect_responder_conflicts(&[&imported], &[&existing]);
+        let conflicts = detect_responder_conflicts(&[&imported], &[&existing], false);
         assert_eq!(conflicts.len(), 1);
 
         // And the reverse.
         let imported2 = make_responder(2, "new-name2", "/test", ResponderMethod::Post);
         let existing2 = make_responder(200, "old-name2", "/test", ResponderMethod::Any);
-        let conflicts2 = detect_responder_conflicts(&[&imported2], &[&existing2]);
+        let conflicts2 = detect_responder_conflicts(&[&imported2], &[&existing2], false);
         assert_eq!(conflicts2.len(), 1);
     }
 
@@ -182,7 +214,7 @@ mod tests {
         // because renaming won't resolve the location+method collision.
         let imported = make_responder(1, "same-name", "/test", ResponderMethod::Get);
         let existing = make_responder(100, "same-name", "/test", ResponderMethod::Get);
-        let conflicts = detect_responder_conflicts(&[&imported], &[&existing]);
+        let conflicts = detect_responder_conflicts(&[&imported], &[&existing], false);
         assert_eq!(conflicts.len(), 1);
         assert!(!conflicts[0].rename_allowed);
     }
@@ -192,7 +224,7 @@ mod tests {
         // Same name but different location → rename IS allowed.
         let imported = make_responder(1, "same-name", "/path-a", ResponderMethod::Get);
         let existing = make_responder(100, "same-name", "/path-b", ResponderMethod::Post);
-        let conflicts = detect_responder_conflicts(&[&imported], &[&existing]);
+        let conflicts = detect_responder_conflicts(&[&imported], &[&existing], false);
         assert_eq!(conflicts.len(), 1);
         assert!(conflicts[0].rename_allowed);
     }
@@ -203,7 +235,8 @@ mod tests {
         let imported = make_responder(1, "resp-a", "/path-b", ResponderMethod::Get);
         let existing_name = make_responder(100, "resp-a", "/other", ResponderMethod::Post);
         let existing_loc = make_responder(200, "resp-b", "/path-b", ResponderMethod::Get);
-        let conflicts = detect_responder_conflicts(&[&imported], &[&existing_name, &existing_loc]);
+        let conflicts =
+            detect_responder_conflicts(&[&imported], &[&existing_name, &existing_loc], false);
         assert_eq!(conflicts.len(), 2);
         // Name conflict allows rename, location conflict does not.
         let name_conflict = conflicts
@@ -222,15 +255,54 @@ mod tests {
     fn responder_conflicts_no_match_different_path() {
         let imported = make_responder(1, "new", "/path-a", ResponderMethod::Get);
         let existing = make_responder(100, "old", "/path-b", ResponderMethod::Get);
-        let conflicts = detect_responder_conflicts(&[&imported], &[&existing]);
+        let conflicts = detect_responder_conflicts(&[&imported], &[&existing], false);
         assert!(conflicts.is_empty());
     }
 
     #[test]
     fn responder_conflicts_no_match_different_method() {
         let imported = make_responder(1, "new", "/test", ResponderMethod::Get);
         let existing = make_responder(100, "old", "/test", ResponderMethod::Post);
-        let conflicts = detect_responder_conflicts(&[&imported], &[&existing]);
+        let conflicts = detect_responder_conflicts(&[&imported], &[&existing], false);
         assert!(conflicts.is_empty());
     }
+
+    #[test]
+    fn strip_prefix_makes_imported_match_existing_without_prefix() {
+        // Imported has prefix "abc", existing has no prefix — same path+method.
+        // Without stripping they don't conflict; with stripping they do.
+        let imported =
+            make_responder_with_prefix(1, "new", "/test", ResponderMethod::Get, Some("abc"));
+        let existing = make_responder(100, "old", "/test", ResponderMethod::Get);
+
+        let without_strip = detect_responder_conflicts(&[&imported], &[&existing], false);
+        assert!(without_strip.is_empty());
+
+        let with_strip = detect_responder_conflicts(&[&imported], &[&existing], true);
+        assert_eq!(with_strip.len(), 1);
+        assert!(!with_strip[0].rename_allowed);
+    }
+
+    #[test]
+    fn strip_prefix_no_effect_when_imported_has_no_prefix() {
+        let imported = make_responder(1, "new", "/test", ResponderMethod::Get);
+        let existing = make_responder(100, "old", "/test", ResponderMethod::Get);
+        let without_strip = detect_responder_conflicts(&[&imported], &[&existing], false);
+        let with_strip = detect_responder_conflicts(&[&imported], &[&existing], true);
+        assert_eq!(without_strip.len(), with_strip.len());
+    }
+
+    #[test]
+    fn strip_prefix_collapses_different_prefixes_to_same_location() {
+        // Two imports with different prefixes but same path — after stripping both
+        // conflict with the same existing responder.
+        let imported_a =
+            make_responder_with_prefix(1, "a", "/test", ResponderMethod::Get, Some("x"));
+        let imported_b =
+            make_responder_with_prefix(2, "b", "/test", ResponderMethod::Get, Some("y"));
+        let existing = make_responder(100, "old", "/test", ResponderMethod::Get);
+
+        let conflicts = detect_responder_conflicts(&[&imported_a, &imported_b], &[&existing], true);
+        assert_eq!(conflicts.len(), 2);
+    }
 }

src/users/user_data/import/importers/responders.rs

@@ -6,8 +6,11 @@ use crate::{
         user_data::{
             export::{ExportedResponder, ExportedResponderRequest},
             import::{
-                ConflictResolution, ImportEntityResult, ImportEntitySelection, remap_tag_ids,
-                resolve_name, should_skip,
+                ConflictResolution, ImportEntityResult, ImportEntitySelection,
+                normalize_responder::{
+                    should_strip_subdomain_prefixes, strip_location_subdomain_prefix,
+                },
+                remap_tag_ids, resolve_name, should_skip,
             },
         },
     },
@@ -34,6 +37,7 @@ pub async fn import_responders<DR: DnsResolver, ET: EmailTransport>(
     let existing_responders = webhooks_api.get_responders().await.unwrap_or_default();
     let mut used_names: HashSet<_> = existing_responders.iter().map(|r| r.name.clone()).collect();
     let mut deleted_ids: HashSet<Uuid> = HashSet::new();
+    let strip_prefix = should_strip_subdomain_prefixes(&api.config, user);
 
     for exported in responders {
         let resp = &exported.responder;
@@ -43,6 +47,15 @@ pub async fn import_responders<DR: DnsResolver, ET: EmailTransport>(
             continue;
         }
 
+        // Compute normalized location once per responder - clone only the location,
+        // not the whole responder, and only when it carries a prefix that must be stripped.
+        let normalized_location = if strip_prefix && resp.location.subdomain_prefix.is_some() {
+            Some(strip_location_subdomain_prefix(&resp.location))
+        } else {
+            None
+        };
+        let location = normalized_location.as_ref().unwrap_or(&resp.location);
+
         let name = resolve_name(&resp.name, selection, &used_names);
         let is_overwrite =
             selection.is_some_and(|s| s.conflict_resolution == Some(ConflictResolution::Overwrite));
@@ -59,7 +72,7 @@ pub async fn import_responders<DR: DnsResolver, ET: EmailTransport>(
             }
 
             // Delete any existing responder that conflicts on location+method.
-            let import_loc = resp.location.to_string();
+            let import_loc = location.to_string();
             if let Some(e) = existing_responders.iter().find(|r| {
                 !deleted_ids.contains(&r.id)
                     && r.location.to_string() == import_loc
@@ -76,7 +89,7 @@ pub async fn import_responders<DR: DnsResolver, ET: EmailTransport>(
         match webhooks_api
             .create_responder(RespondersCreateParams {
                 name: name.clone(),
-                location: resp.location.clone(),
+                location: location.clone(),
                 method: resp.method,
                 enabled: resp.enabled,
                 settings: resp.settings.clone(),