fix(gateway): write machine-scoped bindings from meta-tools bind

Thread X-Mcpmux-Machine-Id through MetaToolCall so bind and resolve
use the same machine identity. Meta-tool binds now persist machine_id
when a device is known, and responses report whether the FeatureSet is
active for the current session.

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

Author: crimsonsunset

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

@@ -33,10 +33,9 @@ use uuid::Uuid;
 pub struct WorkspaceBinding {
     pub id: Uuid,
     pub workspace_root: String,
-    /// Optional OAuth client scope. `None` is a global binding (the only kind
-    /// produced today — resolution stays exact-match-global). The column
-    /// exists for a later per-client routing phase; it is persisted but does
-    /// not affect resolution yet.
+    /// Optional OAuth client scope. `None` is a global binding. When set
+    /// together with `machine_id`, resolution prefers the client+machine pair
+    /// over a machine-only canonical binding on the same path.
     #[serde(default)]
     pub client_id: Option<String>,
     /// Optional machine scope. `None` is a global canonical binding shared
@@ -80,7 +79,7 @@ impl WorkspaceBinding {
 
     /// Construct a binding optionally scoped to an OAuth `client_id`. A `None`
     /// scope is a global binding; `Some(client_id)` restricts the binding to
-    /// that client during resolution.
+    /// that client during resolution when no machine identity is registered.
     pub fn new_scoped_multi(
         workspace_root: impl Into<String>,
         space_id: Uuid,
@@ -101,6 +100,30 @@ impl WorkspaceBinding {
             updated_at: now,
         }
     }
+
+    /// Construct a machine-scoped binding (`client_id` unset). Used when this
+    /// install or the caller's `X-Mcpmux-Machine-Id` header identifies the
+    /// physical host that owns the workspace folder.
+    pub fn new_machine_scoped_multi(
+        workspace_root: impl Into<String>,
+        space_id: Uuid,
+        machine_id: Uuid,
+        feature_set_ids: Vec<String>,
+    ) -> Self {
+        let now = Utc::now();
+        Self {
+            id: Uuid::new_v4(),
+            workspace_root: workspace_root.into(),
+            client_id: None,
+            machine_id: Some(machine_id),
+            label: None,
+            icon: None,
+            space_id,
+            feature_set_ids,
+            created_at: now,
+            updated_at: now,
+        }
+    }
 }
 
 /// Trim-empty helper for optional binding metadata fields.

crates/mcpmux-gateway/src/mcp/handler.rs

@@ -855,7 +855,13 @@ impl ServerHandler for McpMuxGatewayHandler {
             return match self
                 .services
                 .meta_tool_registry
-                .call(&params.name, &oauth_ctx.client_id, session_id, args)
+                .call_from_device(
+                    &params.name,
+                    &oauth_ctx.client_id,
+                    session_id,
+                    args,
+                    oauth_ctx.request_machine_id,
+                )
                 .await
             {
                 Ok(result) => Ok(result),

crates/mcpmux-gateway/src/services/feature_set_resolver.rs

@@ -228,6 +228,29 @@ impl FeatureSetResolverService {
         *self.local_machine_id.write().await = id;
     }
 
+    /// The machine identity that should govern a *binding write* for this
+    /// caller — mirrors Tier 1's read-side priority (request header, then the
+    /// OAuth client's registered machine, then this gateway's own local
+    /// machine identity) so a bind and the resolve that follows it never
+    /// disagree about whose binding it is. `None` means no machine identity
+    /// exists anywhere yet (fresh install with nothing registered) — callers
+    /// should fall back to the pre-machine, client-scoped binding shape.
+    pub async fn effective_machine_id(
+        &self,
+        client_id: Option<&str>,
+        request_machine_id: Option<Uuid>,
+    ) -> Result<Option<Uuid>> {
+        if let Some(id) = request_machine_id {
+            return Ok(Some(id));
+        }
+        if let Some(cid) = client_id {
+            if let Some(client_machine) = self.client_repo.get_machine_id(cid).await? {
+                return Ok(Some(client_machine));
+            }
+        }
+        Ok(*self.local_machine_id.read().await)
+    }
+
     /// Tier 1 exact binding lookup: request machine header, then client machine,
     /// then local machine, then global.
     async fn find_binding_for_roots(

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

@@ -1,10 +1,11 @@
 //! `mcpmux_bind_current_workspace` — persistently layer a FeatureSet onto a workspace binding.
 
 use async_trait::async_trait;
-use mcpmux_core::{normalize_workspace_root, WorkspaceBinding};
+use mcpmux_core::{normalize_workspace_root, WorkspaceBinding, WorkspaceBindingRepository};
 use rmcp::model::CallToolResult;
 use serde_json::{json, Value};
 use tracing::info;
+use uuid::Uuid;
 
 use super::meta_tool_common::{
     caller_space_id, emit_tools_list_changed, emit_workspace_binding_changed, parse_uuid_arg,
@@ -14,6 +15,91 @@ use super::registry::{MetaTool, MetaToolCall, MetaToolError};
 
 pub struct BindCurrentWorkspaceTool;
 
+/// Machine identity for this bind — header, then OAuth client machine, then gateway local.
+async fn effective_machine_for_bind(call: &MetaToolCall<'_>) -> Result<Option<Uuid>, MetaToolError> {
+    call.ctx
+        .resolver
+        .effective_machine_id(Some(call.client_id), call.request_machine_id)
+        .await
+        .map_err(|e| MetaToolError::Internal(e.to_string()))
+}
+
+/// Look up an existing binding row using the same scope the write path will use.
+async fn find_existing_binding_for_bind(
+    binding_repo: &dyn WorkspaceBindingRepository,
+    space_id: &Uuid,
+    machine_id: Option<Uuid>,
+    client_id: &str,
+    normalized: &str,
+) -> Result<Option<WorkspaceBinding>, MetaToolError> {
+    if let Some(mid) = machine_id {
+        return binding_repo
+            .find_exact_for_machine(&mid, normalized, None)
+            .await
+            .map_err(|e| MetaToolError::Internal(e.to_string()));
+    }
+    binding_repo
+        .find_longest_prefix_match(
+            space_id,
+            Some(client_id),
+            &[normalized.to_string()],
+        )
+        .await
+        .map_err(|e| MetaToolError::Internal(e.to_string()))
+}
+
+/// Inputs for the bind tool JSON response (post-write re-resolve for `active`).
+struct BindToolResultInput<'a> {
+    resolver: &'a crate::services::FeatureSetResolverService,
+    session_id: Option<&'a str>,
+    client_id: &'a str,
+    request_machine_id: Option<Uuid>,
+    binding_id: Uuid,
+    workspace_root: &'a str,
+    feature_set_id: Uuid,
+    feature_set_ids: Vec<String>,
+    already_bound: bool,
+    machine_id: Option<Uuid>,
+}
+
+async fn bind_tool_result(input: BindToolResultInput<'_>) -> Result<CallToolResult, MetaToolError> {
+    let fs_id_str = input.feature_set_id.to_string();
+    let resolved = input
+        .resolver
+        .resolve(
+            input.session_id,
+            Some(input.client_id),
+            input.request_machine_id,
+        )
+        .await
+        .map_err(|e| MetaToolError::Internal(e.to_string()))?;
+    let active = resolved
+        .feature_set_ids
+        .iter()
+        .any(|id| id == &fs_id_str);
+
+    let mut body = json!({
+        "ok": true,
+        "binding_id": input.binding_id,
+        "workspace_root": input.workspace_root,
+        "feature_set_id": input.feature_set_id,
+        "feature_set_ids": input.feature_set_ids,
+        "already_bound": input.already_bound,
+        "active": active,
+    });
+    if let Some(mid) = input.machine_id {
+        body["machine_id"] = json!(mid);
+    }
+    if !active {
+        body["note"] = json!(
+            "binding persisted but FeatureSet is not active for this session — \
+             verify machine identity (Settings → Machine Identity) and \
+             X-Mcpmux-Machine-Id on tunneled clients"
+        );
+    }
+    Ok(text_result(body))
+}
+
 #[async_trait]
 impl MetaTool for BindCurrentWorkspaceTool {
     fn name(&self) -> &'static str {
@@ -47,6 +133,7 @@ impl MetaTool for BindCurrentWorkspaceTool {
         let fs_id = parse_uuid_arg(&call.args, "feature_set_id")?;
 
         let space_id = caller_space_id(&call).await?;
+        let machine_id = effective_machine_for_bind(&call).await?;
         let roots = call
             .session_id
             .and_then(|sid| call.ctx.session_roots.get(sid))
@@ -74,32 +161,48 @@ impl MetaTool for BindCurrentWorkspaceTool {
         let caller_client_id = call.client_id.to_string();
 
         // Dedup before consent: repeat binds must not re-prompt the user.
-        if let Some(existing) = binding_repo
-            .find_longest_prefix_match(
-                &space_id,
-                Some(&caller_client_id),
-                std::slice::from_ref(&normalized),
-            )
-            .await?
+        if let Some(existing) = find_existing_binding_for_bind(
+            binding_repo.as_ref(),
+            &space_id,
+            machine_id,
+            &caller_client_id,
+            &normalized,
+        )
+        .await?
         {
             if existing.feature_set_ids.iter().any(|id| id == &fs_id_str) {
-                return Ok(text_result(json!({
-                    "ok": true,
-                    "binding_id": existing.id,
-                    "workspace_root": normalized,
-                    "feature_set_id": fs_id,
-                    "feature_set_ids": existing.feature_set_ids,
-                    "already_bound": true,
-                })));
+                return bind_tool_result(BindToolResultInput {
+                    resolver: call.ctx.resolver.as_ref(),
+                    session_id: call.session_id,
+                    client_id: call.client_id,
+                    request_machine_id: call.request_machine_id,
+                    binding_id: existing.id,
+                    workspace_root: &normalized,
+                    feature_set_id: fs_id,
+                    feature_set_ids: existing.feature_set_ids,
+                    already_bound: true,
+                    machine_id,
+                })
+                .await;
             }
         }
 
-        let summary = format!(
-            "Append FeatureSet '{fs_name}' to workspace '{normalized}' binding \
-             for client '{caller_client_id}' (existing bundles preserved)."
-        );
+        let summary = match machine_id {
+            Some(mid) => format!(
+                "Append FeatureSet '{fs_name}' to workspace '{normalized}' binding \
+                 for machine '{mid}' (existing bundles preserved)."
+            ),
+            None => format!(
+                "Append FeatureSet '{fs_name}' to workspace '{normalized}' binding \
+                 for client '{caller_client_id}' (existing bundles preserved)."
+            ),
+        };
 
         let event_tx = call.ctx.domain_event_tx.clone();
+        let resolver = call.ctx.resolver.clone();
+        let session_id_owned = call.session_id.map(str::to_owned);
+        let caller_client_id_for_response = caller_client_id.clone();
+        let request_machine_id = call.request_machine_id;
         with_approval(
             &call,
             "mcpmux_bind_current_workspace",
@@ -108,14 +211,14 @@ impl MetaTool for BindCurrentWorkspaceTool {
             true,
             call.args.clone(),
             || async move {
-                let fs_id_str = fs_id.to_string();
-                let existing = binding_repo
-                    .find_longest_prefix_match(
-                        &space_id,
-                        Some(&caller_client_id),
-                        std::slice::from_ref(&normalized),
-                    )
-                    .await?;
+                let existing = find_existing_binding_for_bind(
+                    binding_repo.as_ref(),
+                    &space_id,
+                    machine_id,
+                    &caller_client_id,
+                    &normalized,
+                )
+                .await?;
 
                 let (binding_id, feature_set_ids, already_bound) = if let Some(mut binding) =
                     existing
@@ -131,14 +234,35 @@ impl MetaTool for BindCurrentWorkspaceTool {
                     info!(
                         %space_id,
                         client_id = %caller_client_id,
+                        ?machine_id,
                         binding_id = %binding.id,
                         workspace_root = %normalized,
                         feature_set_id = %fs_id,
                         already_bound,
                         feature_set_count = binding.feature_set_ids.len(),
-                        "[meta_tools] bind_current_workspace updated existing scoped binding",
+                        "[meta_tools] bind_current_workspace updated existing binding",
                     );
                     (binding.id, binding.feature_set_ids.clone(), already_bound)
+                } else if let Some(mid) = machine_id {
+                    let binding = WorkspaceBinding::new_machine_scoped_multi(
+                        normalized.clone(),
+                        space_id,
+                        mid,
+                        vec![fs_id_str.clone()],
+                    );
+                    let binding_id = binding.id;
+                    let feature_set_ids = binding.feature_set_ids.clone();
+                    binding_repo.create(&binding).await?;
+                    emit_workspace_binding_changed(&event_tx, space_id, &normalized);
+                    info!(
+                        %space_id,
+                        %mid,
+                        binding_id = %binding_id,
+                        workspace_root = %normalized,
+                        feature_set_id = %fs_id,
+                        "[meta_tools] bind_current_workspace created machine-scoped binding",
+                    );
+                    (binding_id, feature_set_ids, false)
                 } else {
                     let binding = WorkspaceBinding::new_scoped_multi(
                         normalized.clone(),
@@ -149,26 +273,34 @@ impl MetaTool for BindCurrentWorkspaceTool {
                     let binding_id = binding.id;
                     let feature_set_ids = binding.feature_set_ids.clone();
                     binding_repo.create(&binding).await?;
+                    emit_workspace_binding_changed(&event_tx, space_id, &normalized);
                     info!(
                         %space_id,
                         client_id = %caller_client_id,
                         binding_id = %binding_id,
                         workspace_root = %normalized,
                         feature_set_id = %fs_id,
-                        "[meta_tools] bind_current_workspace created scoped binding",
+                        "[meta_tools] bind_current_workspace created client-scoped binding",
                     );
                     (binding_id, feature_set_ids, false)
                 };
 
-                emit_tools_list_changed(&event_tx, space_id);
-                Ok(text_result(json!({
-                    "ok": true,
-                    "binding_id": binding_id,
-                    "workspace_root": normalized,
-                    "feature_set_id": fs_id,
-                    "feature_set_ids": feature_set_ids,
-                    "already_bound": already_bound,
-                })))
+                if !already_bound {
+                    emit_tools_list_changed(&event_tx, space_id);
+                }
+                bind_tool_result(BindToolResultInput {
+                    resolver: resolver.as_ref(),
+                    session_id: session_id_owned.as_deref(),
+                    client_id: &caller_client_id_for_response,
+                    request_machine_id,
+                    binding_id,
+                    workspace_root: &normalized,
+                    feature_set_id: fs_id,
+                    feature_set_ids,
+                    already_bound,
+                    machine_id,
+                })
+                .await
             },
         )
         .await