@livx.cc/appwrap 0.43.0 → 0.46.2

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

@@ -0,0 +1,306 @@
+// Control-channel ADAPTER for the browser-bridge shim (bridge-shim/shim.ts).
+//
+// Phase 1 extraction: the WKWebView primitive (per-profile persistent+isolated stores, manual
+// window creation, CSP-immune eval, snapshot, the bridgeShim handler, SSO popups) now lives in the
+// `webview-control` crate. This file is the thin transport adapter that OWNS the bod-browser wire
+// format + the TCP control channel:
+//   - dials the shim's TCP control port (line-JSON) and serves window ops,
+//   - frames the crate's RAW page payloads into {type:"pageMsg", payload} lines,
+//   - frames RAW eval/snapshot results into {id,result}/{id,error} responses,
+//   - keeps the legacy tauri-window path (no profileId) for back-compat.
+// Env-gated: fully inert unless APPWRAP_BRIDGE_JS points at the built content bundle.
+use base64::Engine;
+use serde_json::{json, Value};
+use std::io::{Read, Write};
+use std::net::TcpStream;
+use std::sync::mpsc::{channel, Sender};
+use std::time::Duration;
+use tauri::{AppHandle, Manager};
+
+use objc2::rc::Retained;
+use objc2::MainThreadMarker;
+use objc2_web_kit::WKWebView;
+
+// The transport-free primitive. This adapter is the ONLY place that knows the bod-browser wire
+// format; the crate stays automation-agnostic.
+use webview_control as wv;
+
+/// Build the page->shim message sink for one webview: wrap the crate's RAW payload into the
+/// {type:"pageMsg", payload} envelope the shim expects. This is the seam — the framing lives here,
+/// never in the crate.
+fn page_sink(tx: Sender<String>) -> wv::MessageSink {
+    Box::new(move |raw: String| {
+        let _ = tx.send(json!({ "type": "pageMsg", "payload": raw }).to_string());
+    })
+}
+
+fn page_port() -> u16 {
+    std::env::var("APPWRAP_BRIDGE_PAGE_PORT").ok().and_then(|s| s.parse().ok()).unwrap_or(9236)
+}
+fn rust_port() -> u16 {
+    std::env::var("APPWRAP_BRIDGE_RUST_PORT").ok().and_then(|s| s.parse().ok()).unwrap_or(9237)
+}
+
+pub fn init(app: AppHandle) {
+    let js_path = match std::env::var("APPWRAP_BRIDGE_JS") {
+        Ok(p) if !p.is_empty() => p,
+        _ => return, // feature off
+    };
+    std::thread::spawn(move || loop {
+        match TcpStream::connect(("127.0.0.1", rust_port())) {
+            Ok(stream) => {
+                eprintln!("[bridge-shim] control connected");
+                run(&app, stream, &js_path);
+                eprintln!("[bridge-shim] control disconnected");
+            }
+            Err(_) => {}
+        }
+        std::thread::sleep(Duration::from_secs(1));
+    });
+}
+
+fn run(app: &AppHandle, mut stream: TcpStream, js_path: &str) {
+    let _ = stream.set_read_timeout(Some(Duration::from_millis(50)));
+    let (tx, rx) = channel::<String>();
+    let mut acc = String::new();
+    let mut buf = [0u8; 65536];
+    loop {
+        while let Ok(line) = rx.try_recv() {
+            if stream.write_all(line.as_bytes()).and_then(|_| stream.write_all(b"\n")).is_err() {
+                return;
+            }
+        }
+        match stream.read(&mut buf) {
+            Ok(0) => return,
+            Ok(n) => {
+                acc.push_str(&String::from_utf8_lossy(&buf[..n]));
+                while let Some(idx) = acc.find('\n') {
+                    let line = acc[..idx].trim().to_string();
+                    acc.drain(..=idx);
+                    if line.is_empty() { continue; }
+                    match serde_json::from_str::<Value>(&line) {
+                        Ok(v) => handle_op(app, &tx, v, js_path),
+                        Err(e) => eprintln!("[bridge-shim] bad line: {e}"),
+                    }
+                }
+            }
+            Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {}
+            Err(_) => return,
+        }
+    }
+}
+
+fn respond(tx: &Sender<String>, id: &str, result: Result<Value, String>) {
+    let msg = match result {
+        Ok(r) => json!({ "id": id, "result": r }),
+        Err(e) => json!({ "id": id, "error": e }),
+    };
+    let _ = tx.send(msg.to_string());
+}
+
+fn handle_op(app: &AppHandle, tx: &Sender<String>, v: Value, js_path: &str) {
+    let id = v["id"].as_str().unwrap_or_default().to_string();
+    let op = v["op"].as_str().unwrap_or_default().to_string();
+    eprintln!("[bridge-shim] op={op} id={id}");
+    let app2 = app.clone();
+    let tx2 = tx.clone();
+    match op.as_str() {
+        "createWindow" => {
+            let label = v["label"].as_str().unwrap_or_default().to_string();
+            let url = v["url"].as_str().unwrap_or("about:blank").to_string();
+            let profile_id = v["profileId"].as_str().unwrap_or_default().to_string();
+            // Re-read the bundle each time — a rebuilt content.js applies to the next window (dev loop).
+            let init_js = match std::fs::read_to_string(js_path) {
+                Ok(bundle) => format!(
+                    "window.__BRIDGE_LABEL={};window.__BRIDGE_PORT={};\n{}",
+                    serde_json::to_string(&label).unwrap(), page_port(), bundle
+                ),
+                Err(e) => { respond(tx, &id, Err(format!("read bundle {js_path}: {e}"))); return; }
+            };
+            // Profile windows take the crate's MANUAL creation path (per-profile persistent store).
+            // Windows without a profileId keep the original tauri path (back-compat).
+            if !profile_id.is_empty() {
+                let idc = id.clone();
+                let init_js2 = init_js.clone();
+                let r = app.run_on_main_thread(move || {
+                    let mtm = MainThreadMarker::new().expect("run_on_main_thread is main");
+                    let res = wv::create_profile_window(mtm, &label, &url, &profile_id, &init_js2, page_sink(tx2.clone()))
+                        .map(|c| json!({ "ok": true, "label": label, "profileId": profile_id, "storeUuid": c.store_uuid, "persistent": c.persistent }));
+                    respond(&tx2, &idc, res);
+                });
+                if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+                return;
+            }
+            let idc = id.clone();
+            let r = app.run_on_main_thread(move || {
+                let parsed = match tauri::Url::parse(&url) {
+                    Ok(u) => u,
+                    Err(e) => { respond(&tx2, &idc, Err(format!("bad url: {e}"))); return; }
+                };
+                let r = tauri::WebviewWindowBuilder::new(&app2, &label, tauri::WebviewUrl::External(parsed))
+                    .title(&label)
+                    .inner_size(1100.0, 800.0)
+                    // Safari-normalized UA at BUILD time (same constraint as the main window).
+                    .user_agent(crate::popup_mac::SAFARI_UA)
+                    .initialization_script(&init_js)
+                    .build();
+                // Install the page->shim message handler on the fresh webview (main thread), plus the
+                // SAME popup machinery the main window gets (SSO window.open child windows).
+                if let Ok(w) = &r {
+                    let tx4 = tx2.clone();
+                    let _ = w.with_webview(move |pw| unsafe {
+                        crate::popup_mac::install(pw.inner() as _, false);
+                        let mtm = MainThreadMarker::new().expect("with_webview runs on main");
+                        wv::install_message_handler(pw.inner() as *mut WKWebView, mtm, page_sink(tx4));
+                    });
+                }
+                respond(&tx2, &idc, r.map(|_| json!({ "ok": true, "label": label })).map_err(|e| e.to_string()));
+            });
+            if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+        }
+        "closeWindow" => {
+            let label = v["label"].as_str().unwrap_or_default().to_string();
+            if wv::profile_webview(&label).is_some() {
+                let idc = id.clone();
+                let r = app.run_on_main_thread(move || {
+                    let ok = wv::close(&label);
+                    respond(&tx2, &idc, if ok { Ok(json!({ "ok": true })) } else { Err(format!("no window {label}")) });
+                });
+                if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+                return;
+            }
+            match app.get_webview_window(&label) {
+                Some(w) => respond(tx, &id, w.close().map(|_| json!({ "ok": true })).map_err(|e| e.to_string())),
+                None => respond(tx, &id, Err(format!("no window {label}"))),
+            }
+        }
+        "navigate" => {
+            let label = v["label"].as_str().unwrap_or_default().to_string();
+            let url = v["url"].as_str().unwrap_or_default().to_string();
+            let idc = id.clone();
+            let r = app.run_on_main_thread(move || {
+                if let Some(wk) = wv::profile_webview(&label) {
+                    let res = unsafe { wv::navigate(Retained::as_ptr(&wk) as *mut WKWebView, &url) };
+                    respond(&tx2, &idc, res.map(|_| json!({ "ok": true })));
+                    return;
+                }
+                let parsed = match tauri::Url::parse(&url) {
+                    Ok(u) => u,
+                    Err(e) => { respond(&tx2, &idc, Err(format!("bad url: {e}"))); return; }
+                };
+                match app2.get_webview_window(&label) {
+                    Some(w) => respond(&tx2, &idc, w.navigate(parsed).map(|_| json!({ "ok": true })).map_err(|e| e.to_string())),
+                    None => respond(&tx2, &idc, Err(format!("no window {label}"))),
+                }
+            });
+            if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+        }
+        "screenshot" => {
+            let label = v["label"].as_str().unwrap_or_default().to_string();
+            let idc = id.clone();
+            let r = app.run_on_main_thread(move || {
+                if let Some(wk) = wv::profile_webview(&label) {
+                    let tx3 = tx2.clone();
+                    let id2 = idc.clone();
+                    unsafe { wv::snapshot(Retained::as_ptr(&wk) as *mut WKWebView, move |r| respond_png(&tx3, &id2, r)) };
+                    return;
+                }
+                let Some(w) = app2.get_webview_window(&label) else {
+                    respond(&tx2, &idc, Err(format!("no window {label}")));
+                    return;
+                };
+                let tx3 = tx2.clone();
+                let id2 = idc.clone();
+                let r = w.with_webview(move |pw| unsafe {
+                    wv::snapshot(pw.inner() as *mut WKWebView, move |r| respond_png(&tx3, &id2, r))
+                });
+                if let Err(e) = r { respond(&tx2, &idc, Err(e.to_string())); }
+            });
+            if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+        }
+        "evalJs" => {
+            // Fire-and-forget JS injection into a window (debug aid + transport fallback probe).
+            let label = v["label"].as_str().unwrap_or_default().to_string();
+            let js = v["js"].as_str().unwrap_or_default().to_string();
+            if wv::profile_webview(&label).is_some() {
+                let idc = id.clone();
+                let r = app.run_on_main_thread(move || {
+                    if let Some(wk) = wv::profile_webview(&label) {
+                        unsafe { wv::inject_script(Retained::as_ptr(&wk) as *mut WKWebView, &js) };
+                        respond(&tx2, &idc, Ok(json!({ "ok": true })));
+                    } else {
+                        respond(&tx2, &idc, Err(format!("no window {label}")));
+                    }
+                });
+                if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+                return;
+            }
+            match app.get_webview_window(&label) {
+                Some(w) => respond(tx, &id, w.eval(&js).map(|_| json!({ "ok": true })).map_err(|e| e.to_string())),
+                None => respond(tx, &id, Err(format!("no window {label}"))),
+            }
+        }
+        "evalAsync" => {
+            // CSP-immune eval with a real (awaited) return value — callAsyncJavaScript. `js` is a
+            // FUNCTION BODY (use `return`). The crate delivers the RAW return string; we frame {json}.
+            let label = v["label"].as_str().unwrap_or_default().to_string();
+            let js = v["js"].as_str().unwrap_or_default().to_string();
+            let idc = id.clone();
+            let r = app.run_on_main_thread(move || {
+                if let Some(wk) = wv::profile_webview(&label) {
+                    let tx3 = tx2.clone();
+                    let id2 = idc.clone();
+                    unsafe { wv::eval_async(Retained::as_ptr(&wk) as *mut WKWebView, js.clone(), move |r| respond_eval(&tx3, &id2, r)) };
+                    return;
+                }
+                let Some(w) = app2.get_webview_window(&label) else {
+                    respond(&tx2, &idc, Err(format!("no window {label}")));
+                    return;
+                };
+                let tx3 = tx2.clone();
+                let id2 = idc.clone();
+                let js2 = js.clone();
+                let r = w.with_webview(move |pw| unsafe {
+                    wv::eval_async(pw.inner() as *mut WKWebView, js2, move |r| respond_eval(&tx3, &id2, r));
+                });
+                if let Err(e) = r { respond(&tx2, &idc, Err(e.to_string())); }
+            });
+            if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+        }
+        "userClose" => {
+            // Verification aid: drive the red-button path WITHOUT touching the registry, so the
+            // windowWillClose delegate is the sole remover — proves user-close hygiene headlessly.
+            let label = v["label"].as_str().unwrap_or_default().to_string();
+            let idc = id.clone();
+            let r = app.run_on_main_thread(move || {
+                let ok = wv::user_close(&label);
+                respond(&tx2, &idc, if ok { Ok(json!({ "ok": true })) } else { Err(format!("no window {label}")) });
+            });
+            if let Err(e) = r { respond(tx, &id, Err(e.to_string())); }
+        }
+        "listWindows" => {
+            // Closed windows are filtered by the crate; actual reaping (which drops objc objects) is
+            // deferred to createWindow, which runs on the main thread.
+            let mut labels: Vec<String> = app.webview_windows().keys().cloned().collect();
+            let profiles: Vec<Value> = wv::list_webviews()
+                .into_iter()
+                .map(|info| {
+                    labels.push(info.label.clone());
+                    json!({ "label": info.label, "profileId": info.profile_id })
+                })
+                .collect();
+            respond(tx, &id, Ok(json!({ "labels": labels, "profiles": profiles })));
+        }
+        _ => respond(tx, &id, Err(format!("unknown op: {op}"))),
+    }
+}
+
+/// Frame a RAW eval return string into the {json} envelope the shim reads (`r.json`).
+fn respond_eval(tx: &Sender<String>, id: &str, r: Result<String, String>) {
+    respond(tx, id, r.map(|out| json!({ "json": out })));
+}
+
+/// Base64-encode the crate's RAW PNG bytes and frame into the {png} envelope.
+fn respond_png(tx: &Sender<String>, id: &str, r: Result<Vec<u8>, String>) {
+    respond(tx, id, r.map(|bytes| json!({ "png": base64::engine::general_purpose::STANDARD.encode(bytes) })));
+}

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)
+}