@livx.cc/appwrap 0.55.0 → 0.57.0

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

@@ -1,522 +0,0 @@
-//! Multiplexed PLUGIN HOST — the bidirectional generalization of `sidecar.rs`.
-//!
-//! Where the sidecar is a ONE-WAY method-RPC to a single Bun process (shell→sidecar request/response,
-//! no window reference), the plugin host is a BIDIRECTIONAL, per-window channel to a single Bun host
-//! process that loads ALL configured plugins (Elya decision: one multiplexed host):
-//!   - the shell EMITS window/page lifecycle EVENTS to the host (window-created, message, closed),
-//!   - the host CALLS native `webview-control` OPS back (a plugin's `WindowCtx` methods) — routed by
-//!     `pluginId × windowId`, dispatched on the main thread, answered with a `result`,
-//!   - handler RPC (`call`/`result`) preserves the sidecar's back-compat path: a plugin's `handlers`
-//!     route exactly like `defineHandlers`.
-//!
-//! Transport = a Unix domain socket (design decision: no port, filesystem-perm'd). The shell BINDS +
-//! listens, spawns `bun <host> --socket <path> --plugins <json>`, and the host connects. Wire = the
-//! same proven line-JSON model as `bridge_mac.rs`, generalized to the plugin envelope. This module is
-//! ADDITIVE — the `desktop.handlers` sidecar (sidecar.rs) is untouched, so `defineHandlers` is unbroken.
-
-use serde_json::{json, Value};
-use std::collections::{HashMap, HashSet};
-use std::io::{BufRead, BufReader, Write};
-use std::os::unix::net::{UnixListener, UnixStream};
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::sync::mpsc::{self, Receiver, Sender, SyncSender};
-use std::sync::{Arc, Mutex, OnceLock};
-use std::time::Duration;
-
-use objc2::rc::Retained;
-use objc2::MainThreadMarker;
-use objc2_web_kit::WKWebView;
-use tauri::{AppHandle, Manager};
-
-use webview_control as wv;
-
-const READY_TIMEOUT: Duration = Duration::from_secs(5);
-const CALL_TIMEOUT: Duration = Duration::from_secs(30);
-
-pub type PluginResult = Result<Value, (String, String)>;
-
-struct PluginHost {
-    /// Handler methods the host advertised (sidecar-compatible RPC surface), builtin-filtered.
-    methods: HashSet<String>,
-    alive: Arc<AtomicBool>,
-    /// Outbound line sink (drained by the writer thread → the socket).
-    out: Sender<String>,
-    /// Pending handler `call`s awaiting a `result`, keyed by our minted id.
-    pending: Arc<Mutex<HashMap<String, Sender<Value>>>>,
-    next_id: AtomicU64,
-    child: Mutex<std::process::Child>,
-    socket_path: String,
-}
-
-static HOST: OnceLock<PluginHost> = OnceLock::new();
-/// Live outbound sink, published for the duration of a connection so `on_window_created` / message
-/// sinks (which fire outside a request/response) can reach the host. None when disconnected.
-static OUT: Mutex<Option<Sender<String>>> = Mutex::new(None);
-
-/// Parse one host line into a routable outcome. Pure — unit-tested.
-enum Line {
-    Ready(Vec<String>),
-    Op { env: Value },
-    Result { id: String, value: Value },
-    Other,
-}
-
-fn parse_line(line: &str) -> Line {
-    let v: Value = match serde_json::from_str(line) {
-        Ok(v) => v,
-        Err(_) => return Line::Other,
-    };
-    match v["kind"].as_str() {
-        Some("ready") => {
-            let methods = v["plugins"]
-                .as_array()
-                .map(|plugins| {
-                    plugins
-                        .iter()
-                        .flat_map(|p| p["methods"].as_array().cloned().unwrap_or_default())
-                        .filter_map(|m| m.as_str().map(str::to_string))
-                        .collect()
-                })
-                .unwrap_or_default();
-            Line::Ready(methods)
-        }
-        Some("op") => Line::Op { env: v },
-        Some("result") => match v["id"].as_str() {
-            Some(id) => Line::Result { id: id.to_string(), value: v },
-            None => Line::Other,
-        },
-        _ => Line::Other,
-    }
-}
-
-/// Drop any handler claim that shadows a built-in namespace (same guard as the sidecar). Pure.
-fn filter_claims(methods: Vec<String>) -> Vec<String> {
-    let (rejected, kept): (Vec<String>, Vec<String>) = methods
-        .into_iter()
-        .partition(|m| crate::BUILTIN_METHOD_PREFIXES.iter().any(|p| m.starts_with(p)));
-    if !rejected.is_empty() {
-        eprintln!("[plugin-host] rejecting handler method(s) that shadow built-ins: {rejected:?}");
-    }
-    kept
-}
-
-/// Resolve which Bun binary to spawn (same policy as the sidecar — stamped path wins, else `bun`).
-fn resolve_runtime(stamped: &str) -> String {
-    if !stamped.is_empty() && std::path::Path::new(stamped).exists() {
-        return stamped.to_string();
-    }
-    eprintln!("[plugin-host] stamped runtime missing/empty ({stamped}) — falling back to `bun` (PATH lookup)");
-    "bun".to_string()
-}
-
-/// Spawn the multiplexed plugin host over a fresh Unix socket and block (≤5s) on its `ready`.
-/// `plugins_json` is the stamped `[{namespace, attachTo, bundlePath}]` array. Degrades to inert on
-/// any failure (the shell runs without plugins). Idempotent (OnceLock).
-pub fn init(app: AppHandle, host_path: &str, runtime: &str, plugins_json: &str) {
-    if HOST.get().is_some() {
-        return;
-    }
-    let socket_path = std::env::temp_dir()
-        .join(format!("appwrap-plugins-{}.sock", std::process::id()))
-        .to_string_lossy()
-        .to_string();
-    let _ = std::fs::remove_file(&socket_path);
-    let listener = match UnixListener::bind(&socket_path) {
-        Ok(l) => l,
-        Err(e) => {
-            eprintln!("[plugin-host] bind {socket_path} failed: {e} — running without plugins");
-            return;
-        }
-    };
-
-    let bun = resolve_runtime(runtime);
-    let mut child = match std::process::Command::new(&bun)
-        .args([host_path, "--socket", &socket_path, "--plugins", plugins_json])
-        .stdin(std::process::Stdio::null())
-        .stdout(std::process::Stdio::piped())
-        .stderr(std::process::Stdio::piped())
-        .spawn()
-    {
-        Ok(c) => c,
-        Err(e) => {
-            eprintln!("[plugin-host] spawn `{bun} {host_path}` failed: {e} — running without plugins");
-            let _ = std::fs::remove_file(&socket_path);
-            return;
-        }
-    };
-    // host stdout/stderr → shell stderr (prefixed) for diagnostics.
-    if let Some(p) = child.stdout.take() {
-        std::thread::spawn(move || {
-            for line in BufReader::new(p).lines().map_while(Result::ok) {
-                eprintln!("[plugin-host:out] {line}");
-            }
-        });
-    }
-    if let Some(p) = child.stderr.take() {
-        std::thread::spawn(move || {
-            for line in BufReader::new(p).lines().map_while(Result::ok) {
-                eprintln!("[plugin-host:err] {line}");
-            }
-        });
-    }
-
-    // Accept the host's connection (bounded — the host connects immediately after spawn).
-    listener.set_nonblocking(false).ok();
-    let stream = match accept_with_timeout(&listener, READY_TIMEOUT) {
-        Some(s) => s,
-        None => {
-            eprintln!("[plugin-host] host did not connect within {READY_TIMEOUT:?} — killing, no plugins");
-            let _ = child.kill();
-            let _ = std::fs::remove_file(&socket_path);
-            return;
-        }
-    };
-    let writer = stream.try_clone().expect("clone unix stream");
-    let reader = stream;
-
-    // Writer thread: drain the outbound channel → the socket.
-    let (out_tx, out_rx): (Sender<String>, Receiver<String>) = mpsc::channel();
-    {
-        let mut w = writer;
-        std::thread::spawn(move || {
-            for line in out_rx {
-                if w.write_all(line.as_bytes()).and_then(|_| w.write_all(b"\n")).is_err() {
-                    break;
-                }
-            }
-        });
-    }
-    *OUT.lock().unwrap() = Some(out_tx.clone());
-
-    let alive = Arc::new(AtomicBool::new(true));
-    let pending: Arc<Mutex<HashMap<String, Sender<Value>>>> = Arc::new(Mutex::new(HashMap::new()));
-
-    // Reader thread: first `ready` unblocks init; then route ops (→ main thread) + resolve results.
-    let (ready_tx, ready_rx): (SyncSender<Option<Vec<String>>>, Receiver<Option<Vec<String>>>) =
-        mpsc::sync_channel(1);
-    let r_alive = alive.clone();
-    let r_pending = pending.clone();
-    let r_out = out_tx.clone();
-    let r_app = app.clone();
-    std::thread::spawn(move || {
-        let mut reader = BufReader::new(reader);
-        let mut got_ready = false;
-        let mut line = String::new();
-        loop {
-            line.clear();
-            match reader.read_line(&mut line) {
-                Ok(0) | Err(_) => break,
-                Ok(_) => {}
-            }
-            let trimmed = line.trim();
-            if trimmed.is_empty() {
-                continue;
-            }
-            match parse_line(trimmed) {
-                Line::Ready(methods) => {
-                    if !got_ready {
-                        got_ready = true;
-                        let _ = ready_tx.send(Some(methods));
-                    }
-                }
-                Line::Op { env } => dispatch_op(&r_app, &r_out, env),
-                Line::Result { id, value } => {
-                    if let Some(tx) = r_pending.lock().unwrap().remove(&id) {
-                        let _ = tx.send(value);
-                    }
-                }
-                Line::Other => eprintln!("[plugin-host] ignoring line: {trimmed}"),
-            }
-        }
-        r_alive.store(false, Ordering::SeqCst);
-        r_pending.lock().unwrap().clear();
-        *OUT.lock().unwrap() = None;
-        if !got_ready {
-            let _ = ready_tx.send(None);
-        }
-        eprintln!("[plugin-host] reader exited — host marked dead");
-    });
-
-    let methods = match ready_rx.recv_timeout(READY_TIMEOUT) {
-        Ok(Some(m)) => filter_claims(m),
-        _ => {
-            eprintln!("[plugin-host] no `ready` within {READY_TIMEOUT:?} — killing, no plugins");
-            let _ = child.kill();
-            let _ = std::fs::remove_file(&socket_path);
-            return;
-        }
-    };
-    eprintln!("[plugin-host] ready — {} handler method(s): {:?}", methods.len(), methods);
-    let _ = HOST.set(PluginHost {
-        methods: methods.into_iter().collect(),
-        alive,
-        out: out_tx,
-        pending,
-        next_id: AtomicU64::new(1),
-        child: Mutex::new(child),
-        socket_path,
-    });
-}
-
-/// Accept one connection, polling in non-blocking mode until `timeout`.
-fn accept_with_timeout(listener: &UnixListener, timeout: Duration) -> Option<UnixStream> {
-    listener.set_nonblocking(true).ok()?;
-    let deadline = std::time::Instant::now() + timeout;
-    loop {
-        match listener.accept() {
-            Ok((s, _)) => {
-                s.set_nonblocking(false).ok();
-                return Some(s);
-            }
-            Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
-                if std::time::Instant::now() >= deadline {
-                    return None;
-                }
-                std::thread::sleep(Duration::from_millis(10));
-            }
-            Err(_) => return None,
-        }
-    }
-}
-
-// ── Events: shell → host (window/page lifecycle). Fire-and-forget via the live OUT sink. ──────────
-
-/// Emit a `window-created` event so the host can fan out to plugins whose `attachTo` matches. Called
-/// from main.rs once a window's webview exists.
-pub fn on_window_created(label: &str, url: &str) {
-    emit_event("window-created", label, json!({ "url": url }));
-}
-
-/// Emit a `window-closed` event (plugin `onClose` + attach teardown).
-pub fn on_window_closed(label: &str) {
-    emit_event("window-closed", label, json!({}));
-}
-
-fn emit_event(method: &str, window_id: &str, params: Value) {
-    if let Some(tx) = OUT.lock().unwrap().as_ref() {
-        let _ = tx.send(json!({ "kind": "event", "method": method, "windowId": window_id, "params": params }).to_string());
-    }
-}
-
-// ── Ops: host → shell (a plugin's WindowCtx call). Dispatched on the main thread, answered `result`. ──
-
-fn dispatch_op(app: &AppHandle, out: &Sender<String>, env: Value) {
-    let id = env["id"].as_str().unwrap_or_default().to_string();
-    let window_id = env["windowId"].as_str().unwrap_or_default().to_string();
-    let method = env["method"].as_str().unwrap_or_default().to_string();
-    let params = env["params"].clone();
-    let app = app.clone();
-    let out = out.clone();
-    let out_err = out.clone();
-    let id_err = id.clone();
-    let r = app.clone().run_on_main_thread(move || {
-        run_op_on_main(&app, &out, &id, &window_id, &method, &params);
-    });
-    if let Err(e) = r {
-        respond(&out_err, &id_err, Err(format!("dispatch failed: {e}")));
-    }
-}
-
-/// Resolve the target window's `*mut WKWebView` (profile window OR the main tauri window) and hand it
-/// to `f` on the main thread. Returns Err if the window is unknown. Mirrors bridge_mac's dual path.
-fn on_webview<F>(app: &AppHandle, label: &str, f: F) -> Result<(), String>
-where
-    F: FnOnce(*mut WKWebView) + Send + 'static,
-{
-    if let Some(wk) = wv::profile_webview(label) {
-        f(Retained::as_ptr(&wk) as *mut WKWebView);
-        return Ok(());
-    }
-    match app.get_webview_window(label) {
-        Some(w) => w
-            .with_webview(move |pw| f(pw.inner() as *mut WKWebView))
-            .map_err(|e| e.to_string()),
-        None => Err(format!("no window {label}")),
-    }
-}
-
-fn run_op_on_main(app: &AppHandle, out: &Sender<String>, id: &str, label: &str, method: &str, params: &Value) {
-    let js = params["js"].as_str().unwrap_or_default().to_string();
-    let url = params["url"].as_str().unwrap_or_default().to_string();
-    match method {
-        "injectScript" => {
-            let res = on_webview(app, label, move |wk| unsafe { wv::inject_script(wk, &js) });
-            respond(out, id, res.map(|_| json!({ "ok": true })));
-        }
-        "postMessage" => {
-            // plugin→page: deliver as a `window` `appwrap:plugin` CustomEvent whose detail is the msg.
-            let payload = serde_json::to_string(&params["msg"]).unwrap_or_else(|_| "null".into());
-            let script = format!(
-                "window.dispatchEvent(new CustomEvent('appwrap:plugin',{{detail:{payload}}}));"
-            );
-            let res = on_webview(app, label, move |wk| unsafe { wv::inject_script(wk, &script) });
-            respond(out, id, res.map(|_| json!({ "ok": true })));
-        }
-        "navigate" => {
-            let res = on_webview(app, label, move |wk| unsafe { let _ = wv::navigate(wk, &url); });
-            respond(out, id, res.map(|_| json!({ "ok": true })));
-        }
-        "back" => respond(out, id, on_webview(app, label, |wk| unsafe { wv::go_back(wk) }).map(|_| json!({ "ok": true }))),
-        "forward" => respond(out, id, on_webview(app, label, |wk| unsafe { wv::go_forward(wk) }).map(|_| json!({ "ok": true }))),
-        "reload" => respond(out, id, on_webview(app, label, |wk| unsafe { wv::reload(wk) }).map(|_| json!({ "ok": true }))),
-        "setInspectable" => respond(out, id, on_webview(app, label, |wk| unsafe { wv::set_inspectable(wk) }).map(|_| json!({ "ok": true }))),
-        "url" => {
-            let out2 = out.clone();
-            let id2 = id.to_string();
-            let res = on_webview(app, label, move |wk| unsafe {
-                wv::eval_async(wk, "return location.href".into(), move |r| {
-                    respond(&out2, &id2, r.map(Value::String).map_err(|e| e));
-                });
-            });
-            if let Err(e) = res { respond(out, id, Err(e)); }
-        }
-        "eval" => {
-            let out2 = out.clone();
-            let id2 = id.to_string();
-            let js2 = js.clone();
-            let res = on_webview(app, label, move |wk| unsafe {
-                wv::eval_async(wk, js2, move |r| {
-                    // The crate delivers a RAW JSON string; parse it so the plugin gets a real value.
-                    respond(&out2, &id2, r.map(|s| serde_json::from_str(&s).unwrap_or(Value::String(s))));
-                });
-            });
-            if let Err(e) = res { respond(out, id, Err(e)); }
-        }
-        "snapshot" => {
-            let out2 = out.clone();
-            let id2 = id.to_string();
-            let res = on_webview(app, label, move |wk| unsafe {
-                wv::snapshot(wk, move |r| {
-                    respond(&out2, &id2, r.map(|bytes| json!(bytes)));
-                });
-            });
-            if let Err(e) = res { respond(out, id, Err(e)); }
-        }
-        "close" => {
-            let ok = wv::close(label);
-            if ok {
-                respond(out, id, Ok(json!({ "ok": true })));
-            } else if let Some(w) = app.get_webview_window(label) {
-                respond(out, id, w.close().map(|_| json!({ "ok": true })).map_err(|e| e.to_string()));
-            } else {
-                respond(out, id, Err(format!("no window {label}")));
-            }
-        }
-        "subscribeMessages" => {
-            // Install the bridgeShim WKScriptMessageHandler → page beacons become `message` events.
-            let out2 = out.clone();
-            let label2 = label.to_string();
-            let res = on_webview(app, label, move |wk| {
-                let mtm = MainThreadMarker::new().expect("run_on_main_thread is main");
-                let sink_out = out2.clone();
-                let sink_label = label2.clone();
-                let sink: wv::MessageSink = Box::new(move |raw: String| {
-                    let _ = sink_out.send(
-                        json!({ "kind": "event", "method": "message", "windowId": sink_label, "params": { "raw": raw } }).to_string(),
-                    );
-                });
-                unsafe { wv::install_message_handler(wk, mtm, sink) };
-            });
-            respond(out, id, res.map(|_| json!({ "ok": true })));
-        }
-        _ => respond(out, id, Err(format!("unknown op: {method}"))),
-    }
-}
-
-fn respond(out: &Sender<String>, id: &str, result: Result<Value, String>) {
-    let msg = match result {
-        Ok(data) => json!({ "kind": "result", "id": id, "ok": true, "data": data }),
-        Err(e) => json!({ "kind": "result", "id": id, "ok": false, "error": { "code": "NATIVE_ERROR", "message": e } }),
-    };
-    let _ = out.send(msg.to_string());
-}
-
-// ── Handler RPC: shell → host (sidecar-compatible `call`/`result`). ───────────────────────────────
-
-/// True if the host advertised this handler method (routed AFTER the sidecar in appwrap_invoke).
-pub fn claims(method: &str) -> bool {
-    HOST.get().is_some_and(|h| h.methods.contains(method))
-}
-
-/// Forward a claimed handler method to the host and block on its response (≤30s).
-pub fn request(method: &str, params: &Value) -> PluginResult {
-    let h = HOST.get().ok_or_else(|| ("NATIVE_ERROR".to_string(), "no plugin host".to_string()))?;
-    if !h.alive.load(Ordering::SeqCst) {
-        return Err(("NATIVE_ERROR".into(), format!("plugin host is not running ({method})")));
-    }
-    let id = format!("ph-{}", h.next_id.fetch_add(1, Ordering::SeqCst));
-    let (tx, rx) = mpsc::channel::<Value>();
-    h.pending.lock().unwrap().insert(id.clone(), tx);
-    let env = json!({ "kind": "call", "id": id, "method": method, "params": params });
-    if h.out.send(env.to_string()).is_err() {
-        h.pending.lock().unwrap().remove(&id);
-        return Err(("NATIVE_ERROR".into(), "plugin host write failed".into()));
-    }
-    match rx.recv_timeout(CALL_TIMEOUT) {
-        Ok(resp) => {
-            if resp["ok"].as_bool() == Some(true) {
-                Ok(resp.get("data").cloned().unwrap_or(Value::Null))
-            } else {
-                let code = resp["error"]["code"].as_str().unwrap_or("NATIVE_ERROR").to_string();
-                let message = resp["error"]["message"].as_str().unwrap_or("handler error").to_string();
-                Err((code, message))
-            }
-        }
-        Err(mpsc::RecvTimeoutError::Timeout) => {
-            h.pending.lock().unwrap().remove(&id);
-            Err(("NATIVE_ERROR".into(), format!("plugin host timeout ({method})")))
-        }
-        Err(mpsc::RecvTimeoutError::Disconnected) => {
-            Err(("NATIVE_ERROR".into(), format!("plugin host died during call ({method})")))
-        }
-    }
-}
-
-/// Kill the host child + remove the socket file (idempotent). Called on main-window teardown.
-pub fn shutdown() {
-    if let Some(h) = HOST.get() {
-        let _ = h.child.lock().unwrap().kill();
-        let _ = std::fs::remove_file(&h.socket_path);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parse_ready_flattens_all_plugin_methods() {
-        match parse_line(r#"{"kind":"ready","plugins":[{"pluginId":"a","methods":["a.x"]},{"pluginId":"b","methods":["b.y","b.z"]}]}"#) {
-            Line::Ready(m) => assert_eq!(m, vec!["a.x".to_string(), "b.y".into(), "b.z".into()]),
-            _ => panic!("expected Ready"),
-        }
-    }
-
-    #[test]
-    fn parse_op_and_result() {
-        assert!(matches!(parse_line(r#"{"kind":"op","id":"op-1","method":"url"}"#), Line::Op { .. }));
-        match parse_line(r#"{"kind":"result","id":"ph-1","ok":true,"data":5}"#) {
-            Line::Result { id, value } => { assert_eq!(id, "ph-1"); assert_eq!(value["data"], 5); }
-            _ => panic!("expected Result"),
-        }
-    }
-
-    #[test]
-    fn parse_malformed_is_other() {
-        assert!(matches!(parse_line("not json"), Line::Other));
-        assert!(matches!(parse_line(r#"{"kind":"result","ok":true}"#), Line::Other)); // no id
-    }
-
-    #[test]
-    fn filter_claims_rejects_builtin_shadowing() {
-        let kept = filter_claims(vec!["storage.get".into(), "myplugin.doThing".into()]);
-        assert_eq!(kept, vec!["myplugin.doThing".to_string()]);
-    }
-
-    #[test]
-    fn resolve_runtime_prefers_existing_stamped_path() {
-        assert_eq!(resolve_runtime("/bin/ls"), "/bin/ls");
-        assert_eq!(resolve_runtime("/nonexistent/bun-xyz"), "bun");
-        assert_eq!(resolve_runtime(""), "bun");
-    }
-}

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

@@ -1,5 +0,0 @@
-// popup_mac moved into the `webview-control` crate (Phase 1 extraction) — this is a re-export shim
-// so existing call sites (`crate::popup_mac::install` / `install_for_profile` / `close_all` /
-// `SAFARI_UA` in main.rs + bridge_mac.rs) resolve unchanged. Edit the source in
-// crates/webview-control/src/popup.rs, not here.
-pub use webview_control::popup::*;