@livx.cc/appwrap 0.55.0 → 0.56.0

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

@@ -1,193 +0,0 @@
-// APNs device-token registration for the SIGNED desktop lane (push.register / push.unregister).
-//
-// macOS delivers the token via NSApplicationDelegate callbacks. Tauri (tao) owns the app delegate
-// and does not implement the two APNs selectors, so we ADD them to tao's delegate class at runtime
-// (class_addMethod — pure addition, no swizzle, nothing existing is displaced). If a future tao
-// ever implements them, class_addMethod returns false and we fail the request honestly instead of
-// silently double-handling. Envelope mirrors the mobile shell (runtime/app/shell/handlers-push.ts):
-// result = { platform: 'apns', token: <hex>, topic: <bundle id> }, 25s timeout, single-flight.
-use std::ffi::CStr;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::sync::Mutex;
-
-use objc2::runtime::{AnyClass, AnyObject, Sel};
-use objc2::{msg_send, sel, MainThreadMarker};
-use objc2_app_kit::NSApplication;
-use objc2_foundation::{NSData, NSError};
-use serde_json::json;
-
-use crate::{deliver, deliver_error, shell};
-
-/// Pending register() waiting for the delegate callback (single-flight, like oauth).
-static PENDING: Mutex<Option<(tauri::WebviewWindow, String)>> = Mutex::new(None);
-/// Cached token — APNs tokens are stable per launch; later register() calls resolve instantly.
-static TOKEN: Mutex<Option<String>> = Mutex::new(None);
-static HOOKS_INSTALLED: AtomicBool = AtomicBool::new(false);
-/// Monotonic id of the current in-flight register. Each new flight bumps it; the timeout thread
-/// captures its own id and only fires if it's STILL the current flight — so a stale timer from a
-/// fast-failed-then-retried flight can't cancel the later one (see `timeout_should_fire`).
-static FLIGHT: AtomicU64 = AtomicU64::new(0);
-
-/// Guard for the timeout thread: fire only if this flight is still the current one. Pure — unit-tested.
-fn timeout_should_fire(my_flight: u64, current_flight: u64) -> bool {
-    my_flight == current_flight
-}
-
-fn deliver_token(window: &tauri::WebviewWindow, id: &str, token: &str) {
-    let resp = json!({ "v": 1, "id": id, "kind": "response", "result": {
-        "platform": "apns", "token": token, "topic": shell().identifier,
-    }});
-    deliver(window, &resp);
-}
-
-/// `push.register` — resolve the APNs device token. Called from appwrap_invoke (any thread);
-/// replies asynchronously from the injected delegate callback (main thread).
-pub fn register(window: tauri::WebviewWindow, id: String) {
-    if let Some(tok) = TOKEN.lock().unwrap().clone() {
-        return deliver_token(&window, &id, &tok);
-    }
-    let my_flight;
-    {
-        let mut p = PENDING.lock().unwrap();
-        if p.is_some() {
-            return deliver_error(&window, &id, "NATIVE_ERROR", "push.register already in progress");
-        }
-        // fetch_add returns the prior value; FLIGHT now holds this flight's unique id.
-        my_flight = FLIGHT.fetch_add(1, Ordering::SeqCst) + 1;
-        *p = Some((window.clone(), id.clone()));
-    }
-    let res = window.run_on_main_thread(|| {
-        let mtm = MainThreadMarker::new().expect("run_on_main_thread guarantees main");
-        if let Err(msg) = install_hooks(mtm) {
-            if let Some((w, id)) = PENDING.lock().unwrap().take() {
-                deliver_error(&w, &id, "NATIVE_ERROR", &msg);
-            }
-            return;
-        }
-        let app = NSApplication::sharedApplication(mtm);
-        app.registerForRemoteNotifications();
-        eprintln!("[push] registerForRemoteNotifications requested");
-    });
-    if let Err(e) = res {
-        if let Some((w, id)) = PENDING.lock().unwrap().take() {
-            deliver_error(&w, &id, "NATIVE_ERROR", &format!("failed to reach main thread: {e}"));
-        }
-        return;
-    }
-    // Mobile-shell parity: 25s cap (kit's push.register timeout is 30s). Only fire if THIS flight
-    // is still current — hold the PENDING lock across the check+take so a concurrent new flight
-    // can't slip in between (else a stale timer could cancel a later register).
-    std::thread::spawn(move || {
-        std::thread::sleep(std::time::Duration::from_secs(25));
-        let mut p = PENDING.lock().unwrap();
-        if timeout_should_fire(my_flight, FLIGHT.load(Ordering::SeqCst)) {
-            if let Some((w, id)) = p.take() {
-                deliver_error(&w, &id, "TIMEOUT", "APNs registration timed out");
-            }
-        }
-    });
-}
-
-/// `push.unregister` — stop receiving remote pushes + drop the cached token.
-pub fn unregister(window: tauri::WebviewWindow, id: String) {
-    TOKEN.lock().unwrap().take();
-    let res = window.clone().run_on_main_thread(move || {
-        let mtm = MainThreadMarker::new().expect("main");
-        NSApplication::sharedApplication(mtm).unregisterForRemoteNotifications();
-        let resp = json!({ "v": 1, "id": id, "kind": "response", "result": null });
-        deliver(&window, &resp);
-    });
-    if let Err(e) = res {
-        eprintln!("[push] unregister failed to reach main thread: {e}");
-    }
-}
-
-/// Add the two APNs delegate methods to tao's NSApplicationDelegate class (once).
-fn install_hooks(mtm: MainThreadMarker) -> Result<(), String> {
-    if HOOKS_INSTALLED.load(Ordering::SeqCst) {
-        return Ok(());
-    }
-    let app = NSApplication::sharedApplication(mtm);
-    let delegate: *mut AnyObject = unsafe { msg_send![&*app, delegate] };
-    if delegate.is_null() {
-        return Err("no NSApplication delegate to hook".into());
-    }
-    let cls: &AnyClass = unsafe { msg_send![delegate, class] };
-    // v@:@@ = void ret, self, _cmd, NSApplication*, NSData*/NSError*.
-    let types: &CStr = c"v@:@@";
-    let ok = unsafe {
-        objc2::ffi::class_addMethod(
-            cls as *const AnyClass as *mut AnyClass,
-            sel!(application:didRegisterForRemoteNotificationsWithDeviceToken:),
-            std::mem::transmute::<
-                extern "C-unwind" fn(*mut AnyObject, Sel, *mut AnyObject, *mut NSData),
-                unsafe extern "C-unwind" fn(),
-            >(did_register),
-            types.as_ptr(),
-        )
-    };
-    let ok2 = unsafe {
-        objc2::ffi::class_addMethod(
-            cls as *const AnyClass as *mut AnyClass,
-            sel!(application:didFailToRegisterForRemoteNotificationsWithError:),
-            std::mem::transmute::<
-                extern "C-unwind" fn(*mut AnyObject, Sel, *mut AnyObject, *mut NSError),
-                unsafe extern "C-unwind" fn(),
-            >(did_fail),
-            types.as_ptr(),
-        )
-    };
-    if !ok.as_bool() || !ok2.as_bool() {
-        return Err(format!(
-            "delegate class {} already implements an APNs selector — refusing to double-handle",
-            cls.name().to_string_lossy()
-        ));
-    }
-    HOOKS_INSTALLED.store(true, Ordering::SeqCst);
-    eprintln!("[push] APNs delegate hooks installed on {}", cls.name().to_string_lossy());
-    Ok(())
-}
-
-extern "C-unwind" fn did_register(_this: *mut AnyObject, _cmd: Sel, _app: *mut AnyObject, token: *mut NSData) {
-    // A null/empty NSData is a failed registration masquerading as success — never cache it or
-    // hand back an empty-string "token" (the app would upload garbage and silently get no pushes).
-    let bytes = if token.is_null() { Vec::new() } else { unsafe { (*token).to_vec() } };
-    if bytes.is_empty() {
-        eprintln!("[push] APNs delivered a null/empty device token — treating as failure");
-        if let Some((w, id)) = PENDING.lock().unwrap().take() {
-            deliver_error(&w, &id, "NATIVE_ERROR", "APNs returned an empty device token");
-        }
-        return;
-    }
-    let hex = bytes.iter().map(|b| format!("{b:02x}")).collect::<String>();
-    eprintln!("[push] APNs token: {hex}");
-    *TOKEN.lock().unwrap() = Some(hex.clone());
-    if let Some((w, id)) = PENDING.lock().unwrap().take() {
-        deliver_token(&w, &id, &hex);
-    }
-}
-
-extern "C-unwind" fn did_fail(_this: *mut AnyObject, _cmd: Sel, _app: *mut AnyObject, error: *mut NSError) {
-    let msg = if error.is_null() {
-        "APNs registration failed".to_string()
-    } else {
-        unsafe { (*error).localizedDescription() }.to_string()
-    };
-    eprintln!("[push] APNs registration failed: {msg}");
-    if let Some((w, id)) = PENDING.lock().unwrap().take() {
-        deliver_error(&w, &id, "NATIVE_ERROR", &msg);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn timeout_fires_only_for_the_current_flight() {
-        // Flight #1's timer must NOT fire once flight #2 has started (fast-fail + retry scenario).
-        assert!(timeout_should_fire(1, 1)); // still current → fire
-        assert!(!timeout_should_fire(1, 2)); // superseded → do NOT cancel the later flight
-        assert!(timeout_should_fire(2, 2));
-    }
-}

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

@@ -1,156 +0,0 @@
-//! `desktop.server` mode: boot a local server command, wait for its port, then the shell navigates the
-//! window to it (see main.rs setup). This is the desktop analogue of iOS/Android `loader:'server'`, but
-//! the URL is served by a child process THIS shell owns — so we also tear it down on window-close.
-//!
-//! Teardown correctness: the server (e.g. `para-chat`) itself spawns children (a backend + a vite
-//! preview). A plain SIGKILL of the direct child would orphan those grandchildren. So we `setsid()` the
-//! child into its OWN process group at spawn, then SIGTERM the WHOLE group on shutdown — every
-//! descendant gets the signal and the server's own exit-guard can reap cleanly.
-
-use std::io::{BufRead, BufReader};
-use std::net::TcpStream;
-use std::os::unix::process::CommandExt;
-use std::process::{Child, Command, Stdio};
-use std::sync::mpsc::{self, Receiver};
-use std::sync::{Mutex, OnceLock};
-use std::time::{Duration, Instant};
-
-/// The booted child + its process-group id (== pid after setsid). Recorded for teardown.
-struct Running {
-    child: Child,
-    pgid: i32,
-}
-
-static RUNNING: OnceLock<Mutex<Option<Running>>> = OnceLock::new();
-
-fn slot() -> &'static Mutex<Option<Running>> {
-    RUNNING.get_or_init(|| Mutex::new(None))
-}
-
-/// Resolved server config (mirrors `ServerConfig` in main.rs).
-pub struct ServerCfg<'a> {
-    pub command: &'a str,
-    pub args: &'a [String],
-    pub cwd: &'a str,
-    pub path: &'a str,
-    /// Non-empty → capture the printed URL from stdout (see `spawn`). Empty → caller uses wait_for_port.
-    pub url_marker: &'a str,
-}
-
-/// Extract the first `http://…`/`https://…` token from a line (up to the next whitespace). Pure.
-fn extract_url(line: &str) -> Option<String> {
-    let start = line.find("http://").or_else(|| line.find("https://"))?;
-    let rest = &line[start..];
-    let end = rest.find(char::is_whitespace).unwrap_or(rest.len());
-    Some(rest[..end].to_string())
-}
-
-/// Spawn the server command in its own process group (setsid), with the CLI-stamped PATH (a
-/// GUI-launched .app has a minimal launchd PATH). Records the child for teardown.
-///
-/// When `url_marker` is non-empty, stdout is piped and a reader thread tees each line to the shell's
-/// stderr AND, on the first line containing the marker, extracts the printed URL and sends it back —
-/// so the shell loads whatever port the server auto-picked (no hardcoded port). Returns that receiver.
-/// When `url_marker` is empty, stdout is inherited and `None` is returned (caller uses `wait_for_port`).
-pub fn spawn(cfg: &ServerCfg) -> std::io::Result<Option<Receiver<String>>> {
-    let capture = !cfg.url_marker.is_empty();
-    let mut cmd = Command::new(cfg.command);
-    cmd.args(cfg.args);
-    if !cfg.cwd.is_empty() {
-        cmd.current_dir(cfg.cwd);
-    }
-    if !cfg.path.is_empty() {
-        cmd.env("PATH", cfg.path);
-    }
-    cmd.stdin(Stdio::null()).stderr(Stdio::inherit());
-    cmd.stdout(if capture { Stdio::piped() } else { Stdio::inherit() });
-    // New session/process group so we can signal every descendant at teardown. setsid() also makes the
-    // child the group leader → its pgid equals its pid.
-    unsafe {
-        cmd.pre_exec(|| {
-            if libc::setsid() == -1 {
-                return Err(std::io::Error::last_os_error());
-            }
-            Ok(())
-        });
-    }
-    let mut child = cmd.spawn()?;
-    let pgid = child.id() as i32;
-
-    let rx = if capture {
-        let stdout = child.stdout.take().expect("piped stdout");
-        let marker = cfg.url_marker.to_string();
-        let (tx, rx) = mpsc::channel::<String>();
-        std::thread::spawn(move || {
-            let mut sent = false;
-            for line in BufReader::new(stdout).lines().map_while(Result::ok) {
-                eprintln!("[server] {line}");
-                if !sent && line.contains(&marker) {
-                    if let Some(url) = extract_url(&line) {
-                        let _ = tx.send(url);
-                        sent = true; // keep draining stdout so the child never blocks on a full pipe
-                    }
-                }
-            }
-        });
-        Some(rx)
-    } else {
-        None
-    };
-
-    *slot().lock().unwrap() = Some(Running { child, pgid });
-    Ok(rx)
-}
-
-/// Poll `127.0.0.1:port` with a TCP connect until it accepts (server is listening) or the timeout
-/// elapses. TCP-accept is a sufficient readiness signal — vite/preview binds the port only once it's
-/// ready to serve. Returns false on timeout.
-pub fn wait_for_port(port: u16, timeout_ms: u64) -> bool {
-    let deadline = Instant::now() + Duration::from_millis(timeout_ms);
-    let addr: std::net::SocketAddr = ([127, 0, 0, 1], port).into();
-    loop {
-        if TcpStream::connect_timeout(&addr, Duration::from_millis(500)).is_ok() {
-            return true;
-        }
-        if Instant::now() >= deadline {
-            return false;
-        }
-        std::thread::sleep(Duration::from_millis(300));
-    }
-}
-
-/// Signal the child's whole process group and reap (idempotent). Called on app exit so the local stack
-/// never outlives the shell. SIGTERM first (lets the server run its exit-guard + reap its own children),
-/// then a short grace, then SIGKILL as a backstop — the server may TRAP SIGTERM without exiting, and a
-/// blocking `wait()` on such a child would hang the exit forever, so we hard-kill the group and only
-/// `try_wait()` (non-blocking) to reap. The negative pgid targets every descendant.
-pub fn shutdown() {
-    if let Some(m) = RUNNING.get() {
-        if let Some(mut r) = m.lock().unwrap().take() {
-            unsafe { libc::kill(-r.pgid, libc::SIGTERM) };
-            std::thread::sleep(Duration::from_millis(1500));
-            unsafe { libc::kill(-r.pgid, libc::SIGKILL) };
-            let _ = r.child.try_wait();
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::extract_url;
-
-    #[test]
-    fn extracts_first_url_up_to_whitespace() {
-        assert_eq!(
-            extract_url("   Frontend:  https://localhost:5050  (ready)"),
-            Some("https://localhost:5050".to_string())
-        );
-        assert_eq!(extract_url("Backend: http://localhost:5051"), Some("http://localhost:5051".to_string()));
-    }
-
-    #[test]
-    fn none_when_no_url() {
-        assert_eq!(extract_url("Frontend ready on port 5050"), None);
-        assert_eq!(extract_url(""), None);
-    }
-}