@livx.cc/appwrap 0.46.1 → 0.46.2

package/runtime-desktop/src-tauri/src/browser_tab.rs

@@ -0,0 +1,193 @@
+// browser_tab — Tauri commands for an EMBEDDED, tear-off/dock-able browser tab (project "browser-tab"
+// Phase 3). Thin front-end-facing wrapper over `webview_control::embedded::Controller`: the same live
+// WKWebView (page + WKWebsiteDataStore session + bridgeShim) is mounted `ChildOf` a host pane NSView
+// and torn off / docked with `set_mount`.
+//
+// R2 (agent-drive, DRY): the tab is created in the crate-level registry keyed by `id` (its label), so
+// the control-channel adapter (`bridge_mac.rs`) — and thus the mcp-desktop-browser MCP — can drive
+// this SAME embedded tab (navigate/eval/screenshot/close) by that id, with NO new TS<->Rust binding.
+//
+// Landmine (a): the pane NSView* is fetched + the webview mounted on the MAIN THREAD, AFTER the pane
+// container has non-zero bounds (we create the container at the caller-supplied paneRect), else blank.
+#[cfg(target_os = "macos")]
+mod imp {
+    use std::collections::HashMap;
+    use std::ffi::c_void;
+    use std::sync::{Mutex, OnceLock};
+
+    use objc2::rc::Retained;
+    use objc2::{MainThreadMarker, MainThreadOnly};
+    use objc2_app_kit::{NSView, NSWindow};
+    use objc2_foundation::{NSPoint, NSRect, NSSize};
+    use objc2_web_kit::WKWebView;
+    use serde::Deserialize;
+    use tauri::Manager;
+
+    use webview_control::embedded::Controller;
+    use webview_control::{CreateSpec, Mount, ViewHandle};
+
+    /// Web-DOM pane rect the front-end reserves (top-left origin, CSS px == points here since the
+    /// shell runs at the window's backing scale). We flip Y to AppKit's bottom-left origin at mount.
+    #[derive(Deserialize, Clone, Copy)]
+    pub struct PaneRect {
+        pub x: f64,
+        pub y: f64,
+        pub width: f64,
+        pub height: f64,
+    }
+
+    // id -> host pane container NSView* (as usize). The container is retained by being a subview of
+    // the window contentView; we hold only its pointer to reposition / reparent / remove it. Access
+    // is main-thread only (all commands marshal via run_on_main_thread), the Mutex just satisfies the
+    // `static` Send/Sync bound for the raw pointer.
+    fn containers() -> &'static Mutex<HashMap<String, usize>> {
+        static CONTAINERS: OnceLock<Mutex<HashMap<String, usize>>> = OnceLock::new();
+        CONTAINERS.get_or_init(|| Mutex::new(HashMap::new()))
+    }
+
+    unsafe fn appkit_rect(content: &NSView, r: PaneRect) -> NSRect {
+        let ch = content.bounds().size.height;
+        NSRect::new(
+            NSPoint::new(r.x, ch - r.y - r.height),
+            NSSize::new(r.width, r.height),
+        )
+    }
+
+    /// The main window's contentView (parent of the shell WKWebView). Main-thread only.
+    unsafe fn content_view(win: &NSWindow) -> Retained<NSView> {
+        win.contentView().expect("main window has a contentView")
+    }
+
+    pub fn create(
+        app: tauri::AppHandle,
+        id: String,
+        url: String,
+        profile_id: String,
+        rect: PaneRect,
+    ) -> Result<(), String> {
+        let win = app.get_webview_window("main").ok_or("no main window")?;
+        // with_webview runs its closure on the AppKit main thread. Build the pane container at
+        // non-zero bounds FIRST (landmine a), then mount the webview ChildOf it — all on main.
+        let (tx, rx) = std::sync::mpsc::channel();
+        win.with_webview(move |w| {
+            let res = (|| -> Result<(), String> {
+                let mtm = MainThreadMarker::new().ok_or("not main thread")?;
+                unsafe {
+                    let wk = &*(w.inner() as *mut WKWebView);
+                    let ns_win = wk.window().ok_or("shell webview has no window")?;
+                    let content = content_view(&ns_win);
+                    let frame = appkit_rect(&content, rect);
+                    let container = NSView::initWithFrame(NSView::alloc(mtm), frame);
+                    content.addSubview(&container);
+                    let cptr = Retained::as_ptr(&container) as *mut c_void;
+                    let handle = ViewHandle::from_ptr(cptr);
+                    let spec = CreateSpec {
+                        label: id.clone(),
+                        url: url.clone(),
+                        profile_id: profile_id.clone(),
+                        init_js: String::new(),
+                        mount: Mount::ChildOf(handle),
+                    };
+                    Controller::new().create_webview(mtm, spec, Box::new(|_raw| {}))?;
+                    // contentView holds a strong ref via addSubview; store only the pointer.
+                    containers().lock().unwrap().insert(id.clone(), cptr as usize);
+                }
+                Ok(())
+            })();
+            let _ = tx.send(res);
+        })
+        .map_err(|e| e.to_string())?;
+        rx.recv().map_err(|e| e.to_string())?
+    }
+
+    pub fn set_mount(app: tauri::AppHandle, id: String, mode: String) -> Result<(), String> {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let win = app.get_webview_window("main").ok_or("no main window")?;
+        win.run_on_main_thread(move || {
+            let res = (|| -> Result<(), String> {
+                let mtm = MainThreadMarker::new().ok_or("not main thread")?;
+                let mount = match mode.as_str() {
+                    "toplevel" => Mount::TopLevel,
+                    "child" => {
+                        let ptr = *containers().lock().unwrap().get(&id).ok_or("no pane for id")?;
+                        unsafe { Mount::ChildOf(ViewHandle::from_ptr(ptr as *mut c_void)) }
+                    }
+                    other => return Err(format!("bad mount mode: {other}")),
+                };
+                if Controller::new().set_mount(mtm, &id, mount) {
+                    Ok(())
+                } else {
+                    Err(format!("no webview {id}"))
+                }
+            })();
+            let _ = tx.send(res);
+        })
+        .map_err(|e| e.to_string())?;
+        rx.recv().map_err(|e| e.to_string())?
+    }
+
+    pub fn navigate(app: tauri::AppHandle, id: String, url: String) -> Result<(), String> {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let win = app.get_webview_window("main").ok_or("no main window")?;
+        win.run_on_main_thread(move || {
+            let res = (|| -> Result<(), String> {
+                let mtm = MainThreadMarker::new().ok_or("not main thread")?;
+                Controller::new().navigate(mtm, &id, &url)
+            })();
+            let _ = tx.send(res);
+        })
+        .map_err(|e| e.to_string())?;
+        rx.recv().map_err(|e| e.to_string())?
+    }
+
+    pub fn close(app: tauri::AppHandle, id: String) -> Result<(), String> {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let win = app.get_webview_window("main").ok_or("no main window")?;
+        win.run_on_main_thread(move || {
+            let res = (|| -> Result<(), String> {
+                let mtm = MainThreadMarker::new().ok_or("not main thread")?;
+                Controller::new().close(mtm, &id);
+                if let Some(ptr) = containers().lock().unwrap().remove(&id) {
+                    unsafe {
+                        let container = &*(ptr as *mut NSView);
+                        container.removeFromSuperview();
+                    }
+                }
+                Ok(())
+            })();
+            let _ = tx.send(res);
+        })
+        .map_err(|e| e.to_string())?;
+        rx.recv().map_err(|e| e.to_string())?
+    }
+}
+
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub fn browser_tab_create(
+    app: tauri::AppHandle,
+    id: String,
+    url: String,
+    profile_id: String,
+    rect: imp::PaneRect,
+) -> Result<String, String> {
+    imp::create(app, id.clone(), url, profile_id, rect).map(|_| id)
+}
+
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub fn browser_tab_set_mount(app: tauri::AppHandle, id: String, mode: String) -> Result<(), String> {
+    imp::set_mount(app, id, mode)
+}
+
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub fn browser_tab_navigate(app: tauri::AppHandle, id: String, url: String) -> Result<(), String> {
+    imp::navigate(app, id, url)
+}
+
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub fn browser_tab_close(app: tauri::AppHandle, id: String) -> Result<(), String> {
+    imp::close(app, id)
+}

package/runtime-desktop/src-tauri/src/main.rs

@@ -17,6 +17,7 @@ use tauri::Manager;
 mod biometrics_mac;
 #[cfg(target_os = "macos")]
 mod bridge_mac;
+mod browser_tab;
 #[cfg(target_os = "macos")]
 mod notifications_mac;
 #[cfg(target_os = "macos")]
@@ -688,7 +689,13 @@ fn main() {
         builder = builder.plugin(tauri_plugin_window_state::Builder::default().build());
     }
     builder
-        .invoke_handler(tauri::generate_handler![appwrap_invoke])
+        .invoke_handler(tauri::generate_handler![
+            appwrap_invoke,
+            browser_tab::browser_tab_create,
+            browser_tab::browser_tab_set_mount,
+            browser_tab::browser_tab_navigate,
+            browser_tab::browser_tab_close,
+        ])
         // Popups are plain NSWindows tauri doesn't know about; with the main (only tauri) window
         // closed, tauri exits the app — but tear popups down explicitly so no dangling windows or
         // live child webviews outlive the shell during teardown (or if the exit is ever prevented).