fix(clone): Phase 1 — clone-time source rewrite and auth header seeding

Autonomous decisions:
- Used existing with_inputs() for input_values — no with_extra_headers builder exists on InstalledServer
- Added PartialEq to ServerSource — needed for assert_eq! in the new unit test

Signed-off-by: crimsonsunset <jsangio1@gmail.com>

Author: crimsonsunset

crates/mcpmux-core/src/application/server.rs

@@ -10,7 +10,7 @@ use uuid::Uuid;
 
 use crate::domain::{
     config::UserServerEntry, DomainEvent, InstallationSource, InstalledServer, ServerDefinition,
-    UpdatePolicy,
+    ServerSource, UpdatePolicy,
 };
 use crate::event_bus::EventSender;
 use crate::repository::{CredentialRepository, InstalledServerRepository, ServerFeatureRepository};
@@ -409,15 +409,18 @@ impl ServerAppService {
         definition.id = new_server_id.clone();
         definition.name = format!("{} ({})", source.display_name(), normalized_suffix);
         definition.alias = Some(alias);
+        definition.source = ServerSource::ManualEntry;
 
-        let server = InstalledServer::new(&space_id_str, &new_server_id)
+        let mut server = InstalledServer::new(&space_id_str, &new_server_id)
             .with_definition(&definition)
             .with_source(InstallationSource::ManualEntry)
             .with_cloned_from(source_server_id)
             .with_display_name_override(display_name_override)
             .with_update_policy(source.update_policy)
             .with_pinned_version(source.pinned_version.clone())
+            .with_inputs(source.input_values.clone())
             .with_enabled(false);
+        server.extra_headers = source.extra_headers.clone();
 
         self.server_repo.install(&server).await?;
 
@@ -545,3 +548,318 @@ impl ServerAppService {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_trait::async_trait;
+    use chrono::Utc;
+    use std::collections::HashMap;
+    use std::path::PathBuf;
+    use std::sync::Arc;
+    use tokio::sync::RwLock;
+
+    use crate::domain::{
+        AuthConfig, InputDefinition, ServerSource, TransportConfig, TransportMetadata,
+    };
+    use crate::event_bus::EventBus;
+    use crate::repository::InstalledServerRepository;
+
+    /// Minimal in-memory repo for clone_server unit tests.
+    struct InMemoryInstalledServerRepository {
+        servers: RwLock<Vec<InstalledServer>>,
+    }
+
+    impl InMemoryInstalledServerRepository {
+        fn new() -> Self {
+            Self {
+                servers: RwLock::new(Vec::new()),
+            }
+        }
+
+        async fn seed(&self, server: InstalledServer) {
+            self.servers.write().await.push(server);
+        }
+
+        async fn get_by_server_id(
+            &self,
+            space_id: &str,
+            server_id: &str,
+        ) -> Option<InstalledServer> {
+            self.servers
+                .read()
+                .await
+                .iter()
+                .find(|s| s.space_id == space_id && s.server_id == server_id)
+                .cloned()
+        }
+    }
+
+    #[async_trait]
+    impl InstalledServerRepository for InMemoryInstalledServerRepository {
+        async fn list(&self) -> crate::repository::RepoResult<Vec<InstalledServer>> {
+            Ok(self.servers.read().await.clone())
+        }
+
+        async fn list_for_space(
+            &self,
+            space_id: &str,
+        ) -> crate::repository::RepoResult<Vec<InstalledServer>> {
+            Ok(self
+                .servers
+                .read()
+                .await
+                .iter()
+                .filter(|s| s.space_id == space_id)
+                .cloned()
+                .collect())
+        }
+
+        async fn list_by_source_file(
+            &self,
+            _file_path: &std::path::Path,
+        ) -> crate::repository::RepoResult<Vec<InstalledServer>> {
+            Ok(Vec::new())
+        }
+
+        async fn get(&self, id: &Uuid) -> crate::repository::RepoResult<Option<InstalledServer>> {
+            Ok(self
+                .servers
+                .read()
+                .await
+                .iter()
+                .find(|s| &s.id == id)
+                .cloned())
+        }
+
+        async fn get_by_server_id(
+            &self,
+            space_id: &str,
+            server_id: &str,
+        ) -> crate::repository::RepoResult<Option<InstalledServer>> {
+            Ok(self.get_by_server_id(space_id, server_id).await)
+        }
+
+        async fn install(&self, server: &InstalledServer) -> crate::repository::RepoResult<()> {
+            self.servers.write().await.push(server.clone());
+            Ok(())
+        }
+
+        async fn update(&self, server: &InstalledServer) -> crate::repository::RepoResult<()> {
+            let mut servers = self.servers.write().await;
+            if let Some(existing) = servers.iter_mut().find(|s| s.id == server.id) {
+                *existing = server.clone();
+                Ok(())
+            } else {
+                anyhow::bail!("server not found for update: {}", server.server_id)
+            }
+        }
+
+        async fn uninstall(&self, id: &Uuid) -> crate::repository::RepoResult<()> {
+            self.servers.write().await.retain(|s| &s.id != id);
+            Ok(())
+        }
+
+        async fn list_enabled(
+            &self,
+            space_id: &str,
+        ) -> crate::repository::RepoResult<Vec<InstalledServer>> {
+            Ok(self
+                .servers
+                .read()
+                .await
+                .iter()
+                .filter(|s| s.space_id == space_id && s.enabled)
+                .cloned()
+                .collect())
+        }
+
+        async fn list_enabled_all(&self) -> crate::repository::RepoResult<Vec<InstalledServer>> {
+            Ok(self
+                .servers
+                .read()
+                .await
+                .iter()
+                .filter(|s| s.enabled)
+                .cloned()
+                .collect())
+        }
+
+        async fn set_enabled(&self, id: &Uuid, enabled: bool) -> crate::repository::RepoResult<()> {
+            if let Some(server) = self.servers.write().await.iter_mut().find(|s| &s.id == id) {
+                server.enabled = enabled;
+            }
+            Ok(())
+        }
+
+        async fn set_oauth_connected(
+            &self,
+            id: &Uuid,
+            connected: bool,
+        ) -> crate::repository::RepoResult<()> {
+            if let Some(server) = self.servers.write().await.iter_mut().find(|s| &s.id == id) {
+                server.oauth_connected = connected;
+            }
+            Ok(())
+        }
+
+        async fn update_inputs(
+            &self,
+            id: &Uuid,
+            input_values: HashMap<String, String>,
+        ) -> crate::repository::RepoResult<()> {
+            if let Some(server) = self.servers.write().await.iter_mut().find(|s| &s.id == id) {
+                server.input_values = input_values;
+            }
+            Ok(())
+        }
+
+        async fn update_cached_definition(
+            &self,
+            id: &Uuid,
+            server_name: Option<String>,
+            cached_definition: Option<String>,
+        ) -> crate::repository::RepoResult<()> {
+            if let Some(server) = self.servers.write().await.iter_mut().find(|s| &s.id == id) {
+                server.server_name = server_name;
+                server.cached_definition = cached_definition;
+            }
+            Ok(())
+        }
+
+        async fn set_display_name_override(
+            &self,
+            id: &Uuid,
+            value: Option<String>,
+        ) -> crate::repository::RepoResult<()> {
+            if let Some(server) = self.servers.write().await.iter_mut().find(|s| &s.id == id) {
+                server.display_name_override = value;
+            }
+            Ok(())
+        }
+
+        async fn update_version_cache(
+            &self,
+            id: &Uuid,
+            latest_available_version: Option<String>,
+            current_version: Option<String>,
+            version_checked_at: chrono::DateTime<Utc>,
+        ) -> crate::repository::RepoResult<()> {
+            if let Some(server) = self.servers.write().await.iter_mut().find(|s| &s.id == id) {
+                server.latest_available_version = latest_available_version;
+                server.current_version = current_version;
+                server.version_checked_at = Some(version_checked_at);
+            }
+            Ok(())
+        }
+    }
+
+    fn user_space_http_definition(server_id: &str) -> ServerDefinition {
+        ServerDefinition {
+            id: server_id.to_string(),
+            name: "PostHog Personal".to_string(),
+            description: None,
+            alias: Some("posthog".to_string()),
+            auth: Some(AuthConfig::ApiKey {
+                instructions: None,
+            }),
+            icon: None,
+            transport: TransportConfig::Http {
+                url: "https://mcp.posthog.com/mcp".to_string(),
+                headers: HashMap::new(),
+                metadata: TransportMetadata {
+                    inputs: vec![InputDefinition {
+                        id: "POSTHOG_API_KEY".to_string(),
+                        label: "API Key".to_string(),
+                        r#type: "password".to_string(),
+                        required: true,
+                        secret: true,
+                        description: None,
+                        default: None,
+                        placeholder: None,
+                        obtain_url: None,
+                        obtain_instructions: None,
+                    }],
+                },
+            },
+            categories: vec![],
+            publisher: None,
+            source: ServerSource::UserSpace {
+                space_id: "space-1".to_string(),
+                file_path: PathBuf::from("/tmp/posthog.json"),
+            },
+            badges: vec![],
+            hosting_type: Default::default(),
+            license: None,
+            license_url: None,
+            installation: None,
+            capabilities: None,
+            sponsored: None,
+            media: None,
+            changelog_url: None,
+        }
+    }
+
+    #[tokio::test]
+    async fn clone_server_rewrites_source_and_seeds_auth_headers() {
+        let space_id = Uuid::new_v4();
+        let repo = Arc::new(InMemoryInstalledServerRepository::new());
+        let event_bus = EventBus::new();
+
+        let parent_headers = HashMap::from([
+            (
+                "Authorization".to_string(),
+                "Bearer phx_parent_token".to_string(),
+            ),
+            (
+                "x-posthog-project-id".to_string(),
+                "345911".to_string(),
+            ),
+        ]);
+        let parent_inputs = HashMap::from([(
+            "POSTHOG_API_KEY".to_string(),
+            "phc_parent_key".to_string(),
+        )]);
+
+        let definition = user_space_http_definition("posthog-personal");
+        let mut source = InstalledServer::new(space_id.to_string(), "posthog-personal")
+            .with_definition(&definition)
+            .with_source(InstallationSource::UserConfig {
+                file_path: PathBuf::from("/tmp/posthog.json"),
+            })
+            .with_inputs(parent_inputs.clone());
+        source.extra_headers = parent_headers.clone();
+        repo.seed(source).await;
+
+        let service = ServerAppService::new(
+            repo.clone(),
+            None,
+            None,
+            event_bus.sender(),
+        );
+
+        let cloned = service
+            .clone_server(space_id, "posthog-personal", "mesh", None, None)
+            .await
+            .expect("clone should succeed");
+
+        assert_eq!(cloned.source, InstallationSource::ManualEntry);
+        assert_eq!(cloned.extra_headers, parent_headers);
+        assert_eq!(cloned.input_values, parent_inputs);
+
+        let definition = cloned
+            .get_definition()
+            .expect("clone should cache definition");
+        assert!(
+            !matches!(definition.source, ServerSource::UserSpace { .. }),
+            "cloned definition source must not remain UserSpace"
+        );
+        assert_eq!(definition.source, ServerSource::ManualEntry);
+
+        let persisted = repo
+            .get_by_server_id(&space_id.to_string(), "posthog-personal-mesh")
+            .await
+            .expect("cloned row should be persisted");
+        assert_eq!(persisted.extra_headers, parent_headers);
+    }
+}

crates/mcpmux-core/src/domain/server.rs

@@ -75,7 +75,7 @@ impl ServerDefinition {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
 #[serde(tag = "type")]
 pub enum ServerSource {
     /// Loaded from a user-defined JSON file in the spaces directory
@@ -88,6 +88,8 @@ pub enum ServerSource {
     Bundled,
     /// Loaded from a remote or custom registry (API, NPM, etc.)
     Registry { url: String, name: String },
+    /// Manually installed clone stored only in SQLite (not a user-space JSON file)
+    ManualEntry,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]