fix(gateway): Phase 4 — gateway fixes + consent polish

Autonomous decisions:
- Adapted non-localhost consent note to fork's minimal launcher page — shows fallback immediately on network bind instead of upstream's full consent HTML
- Extracted load_gateway_auth_disabled_from_repo helper shared by manual start and auto-start paths — matches upstream #205 pattern

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

Author: crimsonsunset

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

@@ -231,6 +231,24 @@ pub(crate) async fn load_network_access(app_state: &AppState) -> bool {
     load_network_access_from_repo(&app_state.settings_repository).await
 }
 
+/// Load the persisted inbound-auth toggle (`gateway.auth_disabled`).
+pub(crate) async fn load_gateway_auth_disabled_from_repo(
+    settings_repository: &Arc<dyn mcpmux_core::AppSettingsRepository>,
+) -> bool {
+    settings_repository
+        .get(GATEWAY_AUTH_DISABLED_KEY)
+        .await
+        .ok()
+        .flatten()
+        .map(|value| value == "true")
+        .unwrap_or(false)
+}
+
+/// Load the persisted inbound-auth toggle for the running app instance.
+pub(crate) async fn load_gateway_auth_disabled(app_state: &AppState) -> bool {
+    load_gateway_auth_disabled_from_repo(&app_state.settings_repository).await
+}
+
 pub(crate) fn advertised_base_url(public_base_url: Option<&str>, port: u16) -> String {
     public_base_url
         .map(str::trim)
@@ -1108,18 +1126,8 @@ pub async fn start_gateway(
     // Seed the system-wide inbound-auth toggle into the running gateway from
     // persisted settings (default: auth required). Live changes go through
     // `set_gateway_auth_disabled`.
-    {
-        let disabled = app_state
-            .settings_repository
-            .get(GATEWAY_AUTH_DISABLED_KEY)
-            .await
-            .ok()
-            .flatten()
-            .map(|v| v == "true")
-            .unwrap_or(false);
-        if disabled {
-            gw_state.write().await.set_auth_disabled(true);
-        }
+    if load_gateway_auth_disabled(&app_state).await {
+        gw_state.write().await.set_auth_disabled(true);
     }
 
     // Subscribe to OAuth completions BEFORE spawn so we don't miss early
@@ -2068,3 +2076,37 @@ mod public_base_url_tests {
         assert_eq!(super::bind_host_for(true), "0.0.0.0");
     }
 }
+
+#[cfg(test)]
+mod gateway_auth_settings_tests {
+    use super::{load_gateway_auth_disabled_from_repo, GATEWAY_AUTH_DISABLED_KEY};
+    use mcpmux_core::AppSettingsRepository;
+    use mcpmux_storage::{Database, SqliteAppSettingsRepository};
+    use std::sync::Arc;
+    use tokio::sync::Mutex;
+
+    fn settings_repo() -> Arc<dyn AppSettingsRepository> {
+        let database = Database::open_in_memory().expect("create in-memory database");
+        Arc::new(SqliteAppSettingsRepository::new(Arc::new(Mutex::new(
+            database,
+        ))))
+    }
+
+    #[tokio::test]
+    async fn auth_remains_required_when_disable_setting_is_missing() {
+        let repository = settings_repo();
+
+        assert!(!load_gateway_auth_disabled_from_repo(&repository).await);
+    }
+
+    #[tokio::test]
+    async fn persisted_disable_setting_is_restored_on_gateway_start() {
+        let repository = settings_repo();
+        repository
+            .set(GATEWAY_AUTH_DISABLED_KEY, "true")
+            .await
+            .unwrap();
+
+        assert!(load_gateway_auth_disabled_from_repo(&repository).await);
+    }
+}

apps/desktop/src-tauri/src/lib.rs

@@ -441,6 +441,9 @@ pub fn run() {
                 // devices on the LAN can reach the gateway; loopback-only otherwise.
                 let network_access =
                     crate::commands::gateway::load_network_access_from_repo(&settings_repo).await;
+                let auth_disabled =
+                    crate::commands::gateway::load_gateway_auth_disabled_from_repo(&settings_repo)
+                        .await;
                 let local_url = format!("http://localhost:{}", final_port);
                 info!("Auto-starting gateway on {} (advertising {})", local_url, url);
 
@@ -500,6 +503,10 @@ pub fn run() {
                 let server = mcpmux_gateway::GatewayServer::new(config, dependencies);
                 let gw_inner_state = server.state();
 
+                if auth_disabled {
+                    gw_inner_state.write().await.set_auth_disabled(true);
+                }
+
                 // Get services from gateway
                 let pool_service = server.pool_service();
                 let feature_service = server.feature_service();

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

@@ -106,7 +106,8 @@ impl McpMuxGatewayHandler {
         let resolver = &services.feature_set_resolver;
         match resolver
             .resolve(session_id, Some(client_id), request_machine_id)
-            .await {
+            .await
+        {
             Ok(resolved) => {
                 info!(
                     %client_id,
@@ -826,14 +827,23 @@ impl ServerHandler for McpMuxGatewayHandler {
         // connection). Without the probe it resolves to empty FS ids and
         // fails "not allowed by the current grants" — breaking the
         // list==call invariant the list handlers already uphold.
-        self.ensure_roots_probed(&context.peer, session_id, &oauth_ctx.client_id, oauth_ctx.request_machine_id)
-            .await;
+        self.ensure_roots_probed(
+            &context.peer,
+            session_id,
+            &oauth_ctx.client_id,
+            oauth_ctx.request_machine_id,
+        )
+        .await;
 
         // Resolve routing once — the binding's target space is authoritative
         // (may differ from oauth_ctx.space_id). Needed both to gate the
         // per-Space meta tools below and to route a normal tool call.
         let (space_id, feature_set_ids) = self
-            .resolve_routing(session_id, &oauth_ctx.client_id, oauth_ctx.request_machine_id)
+            .resolve_routing(
+                session_id,
+                &oauth_ctx.client_id,
+                oauth_ctx.request_machine_id,
+            )
             .await?;
 
         // Intercept meta tools (mcpmux_*) BEFORE feature-set filtering, gated
@@ -979,15 +989,13 @@ impl ServerHandler for McpMuxGatewayHandler {
             .await
             .map_err(|e| McpError::internal_error(format!("Tool call failed: {}", e), None))?;
 
-        // Convert ToolCallResult to MCP CallToolResult
-        let content: Vec<Content> = tool_result
-            .content
-            .into_iter()
-            .filter_map(|v| serde_json::from_value(v).ok())
-            .collect();
+        // Convert ToolCallResult to MCP CallToolResult without dropping
+        // structuredContent or protocol-level _meta from the upstream server.
+        let result = tool_result.into_mcp_result();
 
         // Log result summary - show content types and approximate sizes
-        let content_summary: Vec<String> = content
+        let content_summary: Vec<String> = result
+            .content
             .iter()
             .map(|c| {
                 // Content is Annotated<RawContent>, serialize to inspect type
@@ -1026,18 +1034,11 @@ impl ServerHandler for McpMuxGatewayHandler {
             .collect();
         debug!(
             tool = %params.name,
-            is_error = tool_result.is_error,
+            is_error = result.is_error.unwrap_or(false),
             content = ?content_summary,
             "call_tool result"
         );
 
-        let mut result = if tool_result.is_error {
-            CallToolResult::error(content)
-        } else {
-            CallToolResult::success(content)
-        };
-        result.structured_content = tool_result.structured_content;
-
         Ok(result)
     }
 

crates/mcpmux-gateway/src/pool/routing.rs

@@ -12,7 +12,7 @@ use std::time::Duration;
 
 use anyhow::{anyhow, Result};
 use mcpmux_core::{FeatureType, LogLevel, LogSource, ServerLog, ServerLogManager};
-use rmcp::model::CallToolRequestParams;
+use rmcp::model::{CallToolRequestParams, CallToolResult, Content, Meta};
 use serde_json::Value;
 use tracing::{debug, info, warn};
 use uuid::Uuid;
@@ -53,6 +53,38 @@ pub struct ToolCallResult {
     pub content: Vec<Value>,
     pub structured_content: Option<Value>,
     pub is_error: bool,
+    pub meta: Option<Meta>,
+}
+
+impl ToolCallResult {
+    fn from_mcp_result(result: CallToolResult) -> Self {
+        Self {
+            content: result
+                .content
+                .into_iter()
+                .map(|item| serde_json::to_value(item).unwrap_or(Value::Null))
+                .collect(),
+            structured_content: result.structured_content,
+            is_error: result.is_error.unwrap_or(false),
+            meta: result.meta,
+        }
+    }
+
+    pub(crate) fn into_mcp_result(self) -> CallToolResult {
+        let content: Vec<Content> = self
+            .content
+            .into_iter()
+            .filter_map(|item| serde_json::from_value(item).ok())
+            .collect();
+        let mut result = if self.is_error {
+            CallToolResult::error(content)
+        } else {
+            CallToolResult::success(content)
+        };
+        result.structured_content = self.structured_content;
+        result.meta = self.meta;
+        result
+    }
 }
 
 /// Default timeout for MCP tool calls (60 seconds)
@@ -377,17 +409,7 @@ impl RoutingService {
                         .map_err(|_| anyhow!("Tool call timed out after {:?}", TOOL_CALL_TIMEOUT))?
                         .map_err(|e| anyhow!("MCP call failed: {}", e))?;
 
-                    let content: Vec<Value> = res
-                        .content
-                        .into_iter()
-                        .map(|c| serde_json::to_value(c).unwrap_or(Value::Null))
-                        .collect();
-
-                    Ok(ToolCallResult {
-                        content,
-                        structured_content: res.structured_content,
-                        is_error: res.is_error.unwrap_or(false),
-                    })
+                    Ok(ToolCallResult::from_mcp_result(res))
                 }
                 None => Err(anyhow!("Server instance has no active client")),
             }
@@ -823,7 +845,9 @@ impl RoutingService {
 
 #[cfg(test)]
 mod redirect_tests {
-    use super::format_direct_call_redirect;
+    use super::{format_direct_call_redirect, ToolCallResult};
+    use rmcp::model::{CallToolResult, Content, Meta};
+    use serde_json::json;
 
     #[test]
     fn direct_call_redirect_points_at_invoke_tool() {
@@ -832,4 +856,23 @@ mod redirect_tests {
         assert!(message.contains("\"server_id\": \"github\""));
         assert!(message.contains("\"tool\": \"create_issue\""));
     }
+
+    #[test]
+    fn tool_result_round_trip_preserves_structured_content_and_meta() {
+        let structured = json!({ "matches": [{ "message": "found" }] });
+        let mut meta = Meta::new();
+        meta.0.insert("traceId".to_string(), json!("trace-123"));
+
+        let mut upstream = CallToolResult::structured(structured.clone());
+        upstream.content = vec![Content::text("search completed")];
+        upstream.meta = Some(meta.clone());
+
+        let routed = ToolCallResult::from_mcp_result(upstream);
+        let forwarded = routed.into_mcp_result();
+
+        assert_eq!(forwarded.content, vec![Content::text("search completed")]);
+        assert_eq!(forwarded.structured_content, Some(structured));
+        assert_eq!(forwarded.meta, Some(meta));
+        assert_eq!(forwarded.is_error, Some(false));
+    }
 }

crates/mcpmux-gateway/src/server/handlers.rs

@@ -481,10 +481,42 @@ pub async fn oauth_authorize(
 
     let app_name = branding::DISPLAY_NAME;
 
-    // Minimal launcher page — fires the deep link and closes immediately.
-    // No visible UI: consent lives entirely in the McpMux app (desktop modal
-    // or web admin SSE modal). The fallback section only appears if the
-    // browser blocks window.close() (tab was not script-opened).
+    // When the gateway is exposed beyond loopback, a client that reached this
+    // page from another machine can't complete the desktop consent (the
+    // mcpmux:// deep link fires only on the host). Surface the API-key path so a
+    // remote user isn't left at a dead end.
+    let network_bind = state.read().await.network_bind;
+    let network_note = if network_bind {
+        format!(
+            r#"<p style="margin:0 0 1rem;padding:0.85rem 1rem;border-radius:8px;background:rgba(218,119,86,0.12);border:1px solid rgba(218,119,86,0.3);color:#d8b08c;font-size:0.85rem;line-height:1.45;text-align:left;"><strong style="color:#DA7756;">Connecting from another machine?</strong> This approval only completes on the computer running {app_name}. For a remote or headless client, register an <strong>API-key client</strong> in {app_name} (Clients tab) and connect with that key instead of this browser flow.</p>"#
+        )
+    } else {
+        String::new()
+    };
+    let body_style = if network_bind {
+        String::new()
+    } else {
+        "display: none;".to_string()
+    };
+    let redirect_script = if network_bind {
+        String::new()
+    } else {
+        format!(
+            r#"
+    <script>
+        window.location.href = "{deep_link_url}";
+        setTimeout(function() {{
+            try {{ window.close(); }} catch(e) {{}}
+            // If window.close() was blocked, reveal the fallback.
+            document.body.style.display = '';
+        }}, 300);
+    </script>"#
+        )
+    };
+
+    // Minimal launcher page — fires the deep link and closes immediately on
+    // loopback binds. On network binds the fallback stays visible with guidance
+    // toward API-key clients because the deep link only works on the host.
     let html = format!(
         r##"<!DOCTYPE html>
 <html lang="en">
@@ -494,7 +526,7 @@ pub async fn oauth_authorize(
     <title>{app_name}</title>
     <style>
         body {{
-            display: none;
+            {body_style}
         }}
         .fallback {{
             display: flex;
@@ -522,18 +554,12 @@ pub async fn oauth_authorize(
 <body>
     <div class="fallback">
         <div>
+            {network_note}
             <p>Check {app_name} to complete authorization.</p>
             <a href="{deep_link_url}">Open {app_name}</a>
         </div>
     </div>
-    <script>
-        window.location.href = "{deep_link_url}";
-        setTimeout(function() {{
-            try {{ window.close(); }} catch(e) {{}}
-            // If window.close() was blocked, reveal the fallback.
-            document.body.style.display = '';
-        }}, 300);
-    </script>
+{redirect_script}
 </body>
 </html>"##
     );