fix(gateway): route to resolved space + accept URL client_ids in meta tools

Two related bugs surfaced when Claude Code (DCR-registered) connected to a
Space whose workspace root binding pointed at a different Space.

1. List / call handlers ignored the resolver

   `list_tools`, `list_prompts`, `list_resources`, `get_prompt`,
   `read_resource`, and `call_tool` all read grants via the resolver but
   then queried features from `oauth_ctx.space_id` — which is the OAuth-
   bound space, not the WorkspaceBinding's target. Result: when a binding
   pointed elsewhere, every list returned 0 features (the FS lives in the
   resolved space; the OAuth-context space has no FS by that id).

   Fix: new `McpMuxGatewayHandler::resolve_routing(session_id)` helper that
   returns `(Uuid /* resolved space */, Vec<String> /* fs ids */)`. All
   six handlers route through it and use the resolved space everywhere
   downstream. The OAuth-context space_id is now only used by `oauth_ctx`
   itself for upstream auth — not for routing.

2. Meta-tool dispatcher rejected DCR client ids

   `call_tool`'s meta-tool fast path tried to parse `oauth_ctx.client_id`
   as a `Uuid`, then handed the UUID to `MetaToolRegistry::call`. For
   Claude Code (and any other DCR-registered client) `client_id` is the
   `client_metadata` URL — not a UUID. Result: every `mcpmux_*` tool
   call failed with `"bad client_id"` before the tool could run.

   Fix: meta-tool client_id is now treated as opaque `&str` end-to-end:
     - `MetaToolCall.client_id: &'a Uuid` → `&'a str`
     - `MetaToolRegistry::call(_, &Uuid, _, _)` → `&str`
     - `ApprovalBroker` switches its DashMap keys + every public method
       to `String` / `&str`. Always-allow grants and rate-limit buckets
       still use the same opaque identity, just typed correctly.
     - `respond_to_meta_tool_approval` and `revoke_meta_tool_grant`
       Tauri commands drop the `Uuid::parse_str` step.

Includes a regression test (`url_client_id_works`) using
`https://claude.ai/oauth/claude-code-client-metadata` as the client id
to lock the URL form in.

Signed-off-by: Mohammod Al Amin Ashik <maa.ashik00@gmail.com>

Author: its-mash

apps/desktop/src-tauri/src/commands/meta_tool_approval.rs

@@ -14,7 +14,6 @@ use serde::Serialize;
 use tauri::State;
 use tokio::sync::RwLock;
 use tracing::{info, warn};
-use uuid::Uuid;
 
 use crate::commands::gateway::GatewayAppState;
 
@@ -44,7 +43,6 @@ pub async fn respond_to_meta_tool_approval(
         "deny" => ApprovalDecision::Deny,
         other => return Err(format!("unknown decision: {other}")),
     };
-    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| format!("bad client_id: {e}"))?;
 
     let broker = {
         let state = gateway_state.read().await;
@@ -55,7 +53,10 @@ pub async fn respond_to_meta_tool_approval(
         return Ok(false);
     };
 
-    let resolved = broker.respond(&request_id, client_uuid, &tool_name, decision);
+    // client_id is opaque (UUID for preset clients, OAuth client_metadata
+    // URL for DCR clients like Claude Code). The broker treats it as a
+    // hash key only.
+    let resolved = broker.respond(&request_id, &client_id, &tool_name, decision);
     info!(
         %request_id,
         %client_id,
@@ -86,7 +87,7 @@ pub async fn list_meta_tool_grants(
         .list_always_allow()
         .into_iter()
         .map(|(client_id, tool_name)| MetaToolGrantEntry {
-            client_id: client_id.to_string(),
+            client_id,
             tool_name,
         })
         .collect())
@@ -99,13 +100,12 @@ pub async fn revoke_meta_tool_grant(
     tool_name: String,
     gateway_state: State<'_, Arc<RwLock<GatewayAppState>>>,
 ) -> Result<bool, String> {
-    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| format!("bad client_id: {e}"))?;
     let broker = {
         let state = gateway_state.read().await;
         state.approval_broker.clone()
     };
     let Some(broker) = broker else {
         return Ok(false);
     };
-    Ok(broker.revoke_always_allow(client_uuid, &tool_name))
+    Ok(broker.revoke_always_allow(&client_id, &tool_name))
 }

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

@@ -157,6 +157,34 @@ impl McpMuxGatewayHandler {
         }
     }
 
+    /// Resolve the (Space, FeatureSet ids) the gateway should route a
+    /// session through. The OAuth-context space is *not* used for routing
+    /// — when a `WorkspaceBinding` matches, the binding's target space is
+    /// authoritative and may differ from the OAuth-bound space (this is
+    /// the whole point of workspace-root routing). Pass the returned
+    /// `space_id` to every `feature_service.get_*_for_grants` /
+    /// `routing_service.call_tool` invocation; otherwise the lookup queries
+    /// the wrong space and returns 0 matches.
+    async fn resolve_routing(
+        &self,
+        session_id: Option<&str>,
+    ) -> Result<(uuid::Uuid, Vec<String>), McpError> {
+        let resolved = self
+            .services
+            .authorization_service
+            .resolve(session_id)
+            .await
+            .map_err(|e| McpError::internal_error(format!("Failed to resolve: {e}"), None))?;
+        let space_id = resolved.space_id.ok_or_else(|| {
+            McpError::internal_error("No space resolved (no default space configured)", None)
+        })?;
+        let feature_set_ids = resolved
+            .feature_set_id
+            .map(|fs| vec![fs])
+            .unwrap_or_default();
+        Ok((space_id, feature_set_ids))
+    }
+
     /// Build InitializeResult with negotiated protocol version
     fn build_initialize_result(&self, protocol_version: ProtocolVersion) -> InitializeResult {
         let info = self.get_info();
@@ -416,28 +444,19 @@ impl ServerHandler for McpMuxGatewayHandler {
         _params: Option<PaginatedRequestParams>,
         context: RequestContext<RoleServer>,
     ) -> Result<ListToolsResult, McpError> {
-        let oauth_ctx = self
-            .get_oauth_context(&context.extensions)
-            .map_err(|e| McpError::invalid_params(e.to_string(), None))?;
-
-        // Get client's grants
-        let feature_set_ids = self
-            .services
-            .authorization_service
-            .get_client_grants(
-                &oauth_ctx.client_id,
-                &oauth_ctx.space_id,
-                extract_session_id(&context.extensions).as_deref(),
-            )
-            .await
-            .map_err(|e| McpError::internal_error(format!("Failed to get grants: {}", e), None))?;
-
-        // Get tools via FeatureService
+        // Resolve routing once: the resolver returns the authoritative
+        // (Space, FS) for this session — this may differ from oauth_ctx
+        // when a WorkspaceBinding redirects to another space.
+        let (space_id, feature_set_ids) = self
+            .resolve_routing(extract_session_id(&context.extensions).as_deref())
+            .await?;
+
+        // Get tools via FeatureService — using the *resolved* space.
         let tools = self
             .services
             .pool_services
             .feature_service
-            .get_tools_for_grants(&oauth_ctx.space_id.to_string(), &feature_set_ids)
+            .get_tools_for_grants(&space_id.to_string(), &feature_set_ids)
             .await
             .map_err(|e| McpError::internal_error(format!("Failed to get tools: {}", e), None))?;
 
@@ -500,38 +519,35 @@ impl ServerHandler for McpMuxGatewayHandler {
             && self.services.meta_tool_registry.contains(&params.name)
             && self.services.meta_tool_registry.is_enabled().await
         {
-            let client_uuid = uuid::Uuid::parse_str(&oauth_ctx.client_id)
-                .map_err(|e| McpError::invalid_params(format!("bad client_id: {e}"), None))?;
+            // Note: client_id is the OAuth client identity (a URL for DCR-
+            // registered clients like Claude, a UUID for others). The meta-
+            // tool registry treats it as an opaque string identity key.
             let args: serde_json::Value = params
                 .arguments
                 .map(|a| serde_json::to_value(a).unwrap_or(serde_json::Value::Null))
                 .unwrap_or(serde_json::Value::Null);
             return match self
                 .services
                 .meta_tool_registry
-                .call(&params.name, &client_uuid, session_id, args)
+                .call(&params.name, &oauth_ctx.client_id, session_id, args)
                 .await
             {
                 Ok(result) => Ok(result),
                 Err(e) => Ok(e.into_call_tool_result()),
             };
         }
 
-        // Get client's feature set grants for authorization
-        let feature_set_ids = self
-            .services
-            .authorization_service
-            .get_client_grants(&oauth_ctx.client_id, &oauth_ctx.space_id, session_id)
-            .await
-            .map_err(|e| McpError::internal_error(format!("Failed to get grants: {}", e), None))?;
+        // Resolve routing — the binding's target space is authoritative,
+        // which may differ from oauth_ctx.space_id.
+        let (space_id, feature_set_ids) = self.resolve_routing(session_id).await?;
 
         // Call tool via routing service (handles auth and routing)
         let tool_result = self
             .services
             .pool_services
             .routing_service
             .call_tool(
-                oauth_ctx.space_id,
+                space_id,
                 &feature_set_ids,
                 &params.name,
                 serde_json::to_value(params.arguments.unwrap_or_default()).unwrap_or_default(),
@@ -605,26 +621,15 @@ impl ServerHandler for McpMuxGatewayHandler {
         _params: Option<PaginatedRequestParams>,
         context: RequestContext<RoleServer>,
     ) -> Result<ListPromptsResult, McpError> {
-        let oauth_ctx = self
-            .get_oauth_context(&context.extensions)
-            .map_err(|e| McpError::invalid_params(e.to_string(), None))?;
-
-        let feature_set_ids = self
-            .services
-            .authorization_service
-            .get_client_grants(
-                &oauth_ctx.client_id,
-                &oauth_ctx.space_id,
-                extract_session_id(&context.extensions).as_deref(),
-            )
-            .await
-            .map_err(|e| McpError::internal_error(format!("Failed to get grants: {}", e), None))?;
+        let (space_id, feature_set_ids) = self
+            .resolve_routing(extract_session_id(&context.extensions).as_deref())
+            .await?;
 
         let prompts = self
             .services
             .pool_services
             .feature_service
-            .get_prompts_for_grants(&oauth_ctx.space_id.to_string(), &feature_set_ids)
+            .get_prompts_for_grants(&space_id.to_string(), &feature_set_ids)
             .await
             .map_err(|e| McpError::internal_error(format!("Failed to get prompts: {}", e), None))?;
 
@@ -657,35 +662,23 @@ impl ServerHandler for McpMuxGatewayHandler {
         params: GetPromptRequestParams,
         context: RequestContext<RoleServer>,
     ) -> Result<GetPromptResult, McpError> {
-        let oauth_ctx = self
-            .get_oauth_context(&context.extensions)
-            .map_err(|e| McpError::invalid_params(e.to_string(), None))?;
+        let (space_id, feature_set_ids) = self
+            .resolve_routing(extract_session_id(&context.extensions).as_deref())
+            .await?;
 
         let (server_id, prompt_name) = self
             .services
             .pool_services
             .feature_service
-            .parse_qualified_prompt_name(&oauth_ctx.space_id.to_string(), &params.name)
+            .parse_qualified_prompt_name(&space_id.to_string(), &params.name)
             .await
             .map_err(|e| McpError::invalid_params(format!("Invalid prompt name: {}", e), None))?;
 
-        // Verify authorization
-        let feature_set_ids = self
-            .services
-            .authorization_service
-            .get_client_grants(
-                &oauth_ctx.client_id,
-                &oauth_ctx.space_id,
-                extract_session_id(&context.extensions).as_deref(),
-            )
-            .await
-            .map_err(|e| McpError::internal_error(format!("Failed to get grants: {}", e), None))?;
-
         let authorized_prompts = self
             .services
             .pool_services
             .feature_service
-            .get_prompts_for_grants(&oauth_ctx.space_id.to_string(), &feature_set_ids)
+            .get_prompts_for_grants(&space_id.to_string(), &feature_set_ids)
             .await
             .map_err(|e| {
                 McpError::internal_error(format!("Failed to verify authorization: {}", e), None)
@@ -706,12 +699,7 @@ impl ServerHandler for McpMuxGatewayHandler {
             .services
             .pool_services
             .pool_service
-            .get_prompt(
-                oauth_ctx.space_id,
-                &server_id,
-                &prompt_name,
-                params.arguments,
-            )
+            .get_prompt(space_id, &server_id, &prompt_name, params.arguments)
             .await
             .map_err(|e| McpError::internal_error(format!("Get prompt failed: {}", e), None))?;
 
@@ -728,26 +716,15 @@ impl ServerHandler for McpMuxGatewayHandler {
         _params: Option<PaginatedRequestParams>,
         context: RequestContext<RoleServer>,
     ) -> Result<ListResourcesResult, McpError> {
-        let oauth_ctx = self
-            .get_oauth_context(&context.extensions)
-            .map_err(|e| McpError::invalid_params(e.to_string(), None))?;
-
-        let feature_set_ids = self
-            .services
-            .authorization_service
-            .get_client_grants(
-                &oauth_ctx.client_id,
-                &oauth_ctx.space_id,
-                extract_session_id(&context.extensions).as_deref(),
-            )
-            .await
-            .map_err(|e| McpError::internal_error(format!("Failed to get grants: {}", e), None))?;
+        let (space_id, feature_set_ids) = self
+            .resolve_routing(extract_session_id(&context.extensions).as_deref())
+            .await?;
 
         let resources = self
             .services
             .pool_services
             .feature_service
-            .get_resources_for_grants(&oauth_ctx.space_id.to_string(), &feature_set_ids)
+            .get_resources_for_grants(&space_id.to_string(), &feature_set_ids)
             .await
             .map_err(|e| {
                 McpError::internal_error(format!("Failed to get resources: {}", e), None)
@@ -778,15 +755,15 @@ impl ServerHandler for McpMuxGatewayHandler {
         params: ReadResourceRequestParams,
         context: RequestContext<RoleServer>,
     ) -> Result<ReadResourceResult, McpError> {
-        let oauth_ctx = self
-            .get_oauth_context(&context.extensions)
-            .map_err(|e| McpError::invalid_params(e.to_string(), None))?;
+        let (space_id, feature_set_ids) = self
+            .resolve_routing(extract_session_id(&context.extensions).as_deref())
+            .await?;
 
         let server_id = self
             .services
             .pool_services
             .feature_service
-            .find_server_for_resource(&oauth_ctx.space_id.to_string(), &params.uri)
+            .find_server_for_resource(&space_id.to_string(), &params.uri)
             .await
             .map_err(|e| {
                 McpError::internal_error(format!("Failed to resolve resource: {}", e), None)
@@ -795,23 +772,11 @@ impl ServerHandler for McpMuxGatewayHandler {
                 McpError::invalid_params(format!("Resource '{}' not found", params.uri), None)
             })?;
 
-        // Verify authorization
-        let feature_set_ids = self
-            .services
-            .authorization_service
-            .get_client_grants(
-                &oauth_ctx.client_id,
-                &oauth_ctx.space_id,
-                extract_session_id(&context.extensions).as_deref(),
-            )
-            .await
-            .map_err(|e| McpError::internal_error(format!("Failed to get grants: {}", e), None))?;
-
         let authorized_resources = self
             .services
             .pool_services
             .feature_service
-            .get_resources_for_grants(&oauth_ctx.space_id.to_string(), &feature_set_ids)
+            .get_resources_for_grants(&space_id.to_string(), &feature_set_ids)
             .await
             .map_err(|e| {
                 McpError::internal_error(format!("Failed to verify authorization: {}", e), None)
@@ -832,7 +797,7 @@ impl ServerHandler for McpMuxGatewayHandler {
             .services
             .pool_services
             .pool_service
-            .read_resource(oauth_ctx.space_id, &server_id, &params.uri)
+            .read_resource(space_id, &server_id, &params.uri)
             .await
             .map_err(|e| McpError::internal_error(format!("Read resource failed: {}", e), None))?;