fix(gateway): wire approval publisher on auto-start + focus window on popup

Two bugs around meta-tool write approvals.

1. Approval publisher missing on auto-start

   Only the manual `start_gateway` Tauri command attached the broker
   publisher; the lib.rs auto-start path (which runs on every desktop
   app launch when auto-start is enabled — i.e. virtually always) never
   did. Result: even with the desktop app fully running, every write
   meta tool (`mcpmux_create_feature_set`, `mcpmux_bind_current_workspace`,
   …) returned `approval_required: no desktop attached to mcpmux gateway`.

   Factored the publisher wiring into
   `commands::gateway::attach_approval_publisher` and called it from both
   paths. Also added the missing `state.approval_broker = Some(...)` in
   the auto-start block so the desktop's grants-list / revoke commands
   can reach the broker too.

2. Popups rendered behind other windows

   When a meta-tool approval request fired or a session reported a root
   that needs binding, the dialog/sheet rendered in whichever window the
   user wasn't focused on. Added `focus_main_window(&app)` at two
   chokepoints:
     - In the approval publisher closure, before emitting the
       `meta-tool-approval-request` event.
     - In the domain-event bridge, when forwarding
       `WorkspaceNeedsBinding` (which triggers the binding sheet).

   `unminimize` + `show` + `set_focus` covers minimized, hidden behind
   another app, and tray-hidden states.

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

Author: its-mash

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

@@ -114,6 +114,62 @@ pub(crate) async fn shutdown_gateway_handle(mut handle: mcpmux_gateway::GatewayS
     }
 }
 
+/// Bring the main webview window forward so the user sees a popup the
+/// gateway just emitted. Best-effort — silently no-ops when the window
+/// doesn't exist (rare, e.g. during teardown). Used by the approval
+/// publisher and the WorkspaceNeedsBinding bridge so an LLM tool call or
+/// a fresh client connection automatically draws the user's eye to the
+/// mcpmux app instead of the dialog rendering invisibly under another
+/// window.
+pub(crate) fn focus_main_window<R: tauri::Runtime>(app: &tauri::AppHandle<R>) {
+    use tauri::Manager;
+    let Some(window) = app.get_webview_window("main") else {
+        return;
+    };
+    // unminimize + show + set_focus together cover every state the user
+    // could have left the window in (minimized, hidden behind another
+    // app, hidden by user via the close-to-tray flow).
+    let _ = window.unminimize();
+    let _ = window.show();
+    let _ = window.set_focus();
+}
+
+/// Wire the meta-tool approval broker to the desktop event bus so write
+/// tools (e.g. `mcpmux_bind_current_workspace`) can prompt the React
+/// dialog. Both the manual `start_gateway` command and the lib.rs
+/// auto-start path must call this — without it the broker stays
+/// publisher-less and every write surfaces as
+/// `approval_required: no desktop attached to mcpmux gateway`.
+pub(crate) async fn attach_approval_publisher<R: tauri::Runtime>(
+    approval_broker: &Arc<mcpmux_gateway::services::ApprovalBroker>,
+    app_handle: tauri::AppHandle<R>,
+) {
+    let publisher: mcpmux_gateway::services::meta_tools::ApprovalPublisher = Arc::new(move |req| {
+        let app_handle = app_handle.clone();
+        Box::pin(async move {
+            // Bring the window forward BEFORE emitting so the dialog
+            // animates into a visible window — otherwise it'd render
+            // behind whatever the user is currently focused on.
+            focus_main_window(&app_handle);
+            // Emit the request; the React layer owns rendering +
+            // collecting the user's decision. Failure to emit means
+            // no desktop frontend is listening — broker maps that to
+            // "approval_required" to the calling tool.
+            match app_handle.emit("meta-tool-approval-request", &req) {
+                Ok(()) => true,
+                Err(e) => {
+                    tracing::warn!(
+                        error = %e,
+                        "[meta-tool] failed to emit approval request"
+                    );
+                    false
+                }
+            }
+        })
+    });
+    approval_broker.set_publisher(publisher).await;
+}
+
 /// Wires up ServerManager state + the OAuth completion handler + the
 /// periodic refresh loop after a GatewayServer has been spawned.
 ///
@@ -245,6 +301,14 @@ pub fn start_domain_event_bridge(
         while let Ok(event) = event_rx.recv().await {
             let event_type = event.type_name();
 
+            // Some domain events imply a popup the user must see (a workspace
+            // root needs binding, a backend wants OAuth, etc.). Bring the
+            // window forward BEFORE emitting so the popup animates into a
+            // visible window instead of rendering behind another app.
+            if matches!(event, DomainEvent::WorkspaceNeedsBinding { .. }) {
+                focus_main_window(&app_handle_clone);
+            }
+
             // Map domain events to UI channels
             let (channel, payload) = map_domain_event_to_ui(&event);
 
@@ -822,30 +886,7 @@ pub async fn start_gateway(
     // Meta-tool approval broker — attach a Tauri-event publisher so
     // incoming approval requests reach the React dialog.
     let approval_broker = server.approval_broker();
-    {
-        let app_handle_for_broker = app_handle.clone();
-        let publisher: mcpmux_gateway::services::meta_tools::ApprovalPublisher =
-            std::sync::Arc::new(move |req| {
-                let app_handle = app_handle_for_broker.clone();
-                Box::pin(async move {
-                    // Emit the request; the React layer owns rendering +
-                    // collecting the user's decision. Failure to emit means
-                    // no desktop frontend is listening — broker maps that to
-                    // "approval_required" to the calling tool.
-                    match app_handle.emit("meta-tool-approval-request", &req) {
-                        Ok(()) => true,
-                        Err(e) => {
-                            tracing::warn!(
-                                error = %e,
-                                "[meta-tool] failed to emit approval request"
-                            );
-                            false
-                        }
-                    }
-                })
-            });
-        approval_broker.set_publisher(publisher).await;
-    }
+    attach_approval_publisher(&approval_broker, app_handle.clone()).await;
 
     // Start domain event bridge (clean architecture)
     start_domain_event_bridge(&app_handle, gw_state.clone());

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

@@ -473,6 +473,16 @@ pub fn run() {
                 let event_emitter = server.event_emitter();
                 let grant_service = server.grant_service();
                 let session_roots = server.session_roots();
+                let approval_broker = server.approval_broker();
+
+                // Wire the approval broker to the desktop event bus so
+                // write meta tools can prompt the React dialog. Without
+                // this, every write surfaces as "no desktop attached".
+                crate::commands::gateway::attach_approval_publisher(
+                    &approval_broker,
+                    app_handle_for_sm.clone(),
+                )
+                .await;
 
                 // Start domain event bridge
                 crate::commands::gateway::start_domain_event_bridge(&app_handle_for_sm, gw_inner_state.clone());
@@ -510,6 +520,7 @@ pub fn run() {
                 state.feature_service = Some(feature_service);
                 state.event_emitter = Some(event_emitter);
                 state.grant_service = Some(grant_service);
+                state.approval_broker = Some(approval_broker);
                 state.session_roots = Some(session_roots);
 
                 info!(