fix(gateway): upsert workspace binding in bind_current_workspace

Rebind an existing workspace root via update instead of insert, avoiding
UNIQUE constraint failures when Starter or UI bindings already exist.

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

Author: crimsonsunset

crates/mcpmux-gateway/src/services/meta_tools/tools.rs

@@ -18,6 +18,7 @@ use super::approval::{ApprovalPayload, ApprovalScope};
 use super::registry::{
     MetaTool, MetaToolCall, MetaToolError, SESSION_OVERRIDES_REQUIRE_APPROVAL_KEY,
 };
+use super::workspace_server::emit_workspace_binding_changed;
 use crate::services::ResolvedFeatureSet;
 
 /// Fire a `FeatureSetMembersChanged` event so MCPNotifier pushes a
@@ -1030,19 +1031,46 @@ impl MetaTool for BindCurrentWorkspaceTool {
             true,
             call.args.clone(),
             || async move {
-                let binding =
-                    WorkspaceBinding::new(normalized.clone(), space_id, fs_id.to_string());
-                binding_repo.create(&binding).await?;
-                info!(
-                    %space_id,
-                    workspace_root = %normalized,
-                    feature_set_id = %fs_id,
-                    "[meta_tools] bind_current_workspace applied",
-                );
+                let fs_id_str = fs_id.to_string();
+                let existing = binding_repo
+                    .list()
+                    .await?
+                    .into_iter()
+                    .find(|b| b.workspace_root == normalized);
+
+                let binding_id = if let Some(mut binding) = existing {
+                    binding.space_id = space_id;
+                    binding.feature_set_ids = vec![fs_id_str.clone()];
+                    binding.updated_at = chrono::Utc::now();
+                    binding_repo.update(&binding).await?;
+                    emit_workspace_binding_changed(&event_tx, space_id, &normalized);
+                    info!(
+                        %space_id,
+                        binding_id = %binding.id,
+                        workspace_root = %normalized,
+                        feature_set_id = %fs_id,
+                        "[meta_tools] bind_current_workspace updated existing binding",
+                    );
+                    binding.id
+                } else {
+                    let binding =
+                        WorkspaceBinding::new(normalized.clone(), space_id, fs_id_str.clone());
+                    let binding_id = binding.id;
+                    binding_repo.create(&binding).await?;
+                    info!(
+                        %space_id,
+                        binding_id = %binding_id,
+                        workspace_root = %normalized,
+                        feature_set_id = %fs_id,
+                        "[meta_tools] bind_current_workspace created binding",
+                    );
+                    binding_id
+                };
+
                 emit_tools_list_changed(&event_tx, space_id);
                 Ok(text_result(json!({
                     "ok": true,
-                    "binding_id": binding.id,
+                    "binding_id": binding_id,
                     "workspace_root": normalized,
                     "feature_set_id": fs_id,
                 })))

crates/mcpmux-gateway/src/services/meta_tools/workspace_server.rs

@@ -50,7 +50,7 @@ async fn resolve_workspace_binding(
     Ok((binding, normalized))
 }
 
-fn emit_workspace_binding_changed(
+pub(crate) fn emit_workspace_binding_changed(
     event_tx: &broadcast::Sender<DomainEvent>,
     space_id: Uuid,
     workspace_root: &str,

tests/rust/tests/integration/meta_tools.rs

@@ -14,7 +14,7 @@ use mcpmux_core::{
     normalize_workspace_root, Client, DomainEvent, FeatureSet, FeatureSetMember,
     FeatureSetRepository, InboundMcpClientRepository, InstalledServer, InstalledServerRepository,
     MemberMode, MemberType, ServerFeature, ServerFeatureRepository, SpaceRepository,
-    WorkspaceBindingRepository,
+    WorkspaceBinding, WorkspaceBindingRepository,
 };
 use mcpmux_gateway::pool::FeatureService;
 use mcpmux_gateway::services::{
@@ -759,6 +759,61 @@ async fn bind_current_workspace_creates_binding_with_normalized_root() {
     );
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn bind_current_workspace_updates_existing_binding_for_same_root() {
+    let f = Fixture::new().await;
+    f.attach_auto_publisher(ApprovalDecision::AllowOnce);
+    let input = if cfg!(windows) {
+        "D:\\Projects\\Android\\MyApp\\"
+    } else {
+        "/home/me/projects/android/myapp/"
+    };
+    let normalized = normalize_workspace_root(input);
+    f.session_roots.set(&f.session_id, [input]);
+
+    let fs_full_id = {
+        let sets = f
+            .feature_set_repo
+            .list_by_space(&f.space_id.to_string())
+            .await
+            .unwrap();
+        let full = sets
+            .iter()
+            .find(|fs| fs.name == "Full Access")
+            .expect("Full Access FS");
+        Uuid::parse_str(&full.id).unwrap()
+    };
+
+    // Seed an existing binding (simulates Workspaces UI or prior bind).
+    let starter = WorkspaceBinding::new(
+        normalized.clone(),
+        f.space_id,
+        f.fs_android_id.to_string(),
+    );
+    f.binding_repo.create(&starter).await.unwrap();
+
+    let result = f
+        .registry
+        .call(
+            "mcpmux_bind_current_workspace",
+            &f.client_id,
+            Some(&f.session_id),
+            json!({ "feature_set_id": fs_full_id.to_string() }),
+        )
+        .await
+        .unwrap();
+    assert!(!Fixture::is_error(&result));
+
+    let bindings = f.binding_repo.list_for_space(&f.space_id).await.unwrap();
+    assert_eq!(bindings.len(), 1, "must not insert a second binding row");
+    assert_eq!(bindings[0].id, starter.id, "must reuse existing binding id");
+    assert_eq!(bindings[0].workspace_root, normalized);
+    assert_eq!(
+        bindings[0].feature_set_ids,
+        vec![fs_full_id.to_string()]
+    );
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn invalid_feature_set_argument_rejected() {
     let f = Fixture::new().await;