@livx.cc/appwrap 0.42.4 → 0.46.1

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

@@ -0,0 +1,202 @@
+// macOS local notifications (notifications.requestPermission / .schedule / .pending) via
+// UNUserNotificationCenter.
+//
+// Why not tauri-plugin-notification: its desktop path is notify-rust (fire-and-forget), which has NO
+// click callback and no real scheduling — so a tapped notification can never route a deep link. We
+// post local notifications ourselves through UNUserNotificationCenter and install a delegate whose
+// `didReceiveNotificationResponse` reads the `deepLink` from the notification's userInfo and routes it
+// through the SAME warm/cold `deeplink.open` path as an OS open (crate::route_deeplink). A tap without
+// a deepLink just activates the app (no event), matching the contract.
+//
+// Delivery caveat: UNUserNotificationCenter only delivers from a bundled `.app` with a bundle id. Under
+// an unbundled `cargo run` (dev) authorization/scheduling may no-op — the built `.app` is the real
+// surface. The kit contract is unchanged: the demo still calls `schedule({ ..., deepLink })`.
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Mutex;
+
+use block2::RcBlock;
+use objc2::rc::Retained;
+use objc2::runtime::{Bool, NSObject, NSObjectProtocol, ProtocolObject};
+use objc2::{define_class, msg_send, MainThreadMarker, MainThreadOnly};
+use objc2_foundation::{ns_string, NSArray, NSDictionary, NSError, NSString};
+use objc2_user_notifications::{
+    UNAuthorizationOptions, UNMutableNotificationContent, UNNotification, UNNotificationPresentationOptions,
+    UNNotificationRequest, UNNotificationResponse, UNTimeIntervalNotificationTrigger,
+    UNUserNotificationCenter, UNUserNotificationCenterDelegate,
+};
+use serde_json::{json, Value};
+
+use crate::{deliver, route_deeplink};
+
+// The notification-center delegate — a plain NSObject subclass conforming to the delegate protocol.
+// No ivars: taps route through the global `route_deeplink` (which reaches the main window via the
+// stashed AppHandle), so the delegate holds no state.
+define_class!(
+    #[unsafe(super(NSObject))]
+    #[thread_kind = MainThreadOnly]
+    #[name = "AppwrapUNDelegate"]
+    struct UNDelegate;
+
+    unsafe impl NSObjectProtocol for UNDelegate {}
+
+    unsafe impl UNUserNotificationCenterDelegate for UNDelegate {
+        // Show the banner even when the app is frontmost (default macOS behaviour is to suppress a
+        // notification whose app is active) so a scheduled notification is visible + tappable in-app.
+        #[unsafe(method(userNotificationCenter:willPresentNotification:withCompletionHandler:))]
+        fn will_present(
+            &self,
+            _center: &UNUserNotificationCenter,
+            _notification: &UNNotification,
+            completion: &block2::DynBlock<dyn Fn(UNNotificationPresentationOptions)>,
+        ) {
+            completion.call((UNNotificationPresentationOptions::Banner | UNNotificationPresentationOptions::Sound,));
+        }
+
+        // A notification was tapped. If it carries a `deepLink` in userInfo, route it through the same
+        // warm/cold path as an OS deep-link open; otherwise the app just activates (no event).
+        #[unsafe(method(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:))]
+        fn did_receive(
+            &self,
+            _center: &UNUserNotificationCenter,
+            response: &UNNotificationResponse,
+            completion: &block2::DynBlock<dyn Fn()>,
+        ) {
+            let user_info = response.notification().request().content().userInfo();
+            let val: *mut NSString = unsafe { msg_send![&*user_info, objectForKey: ns_string!("deepLink")] };
+            if !val.is_null() {
+                let url = unsafe { (*val).to_string() };
+                if !url.is_empty() {
+                    eprintln!("[notify] tapped → deeplink.open ← {url}");
+                    route_deeplink(&url);
+                } else {
+                    eprintln!("[notify] tapped (empty deepLink) — activate only");
+                }
+            } else {
+                eprintln!("[notify] tapped (no deepLink) — activate only");
+            }
+            completion.call(());
+        }
+    }
+);
+
+/// Strong ref to the delegate — UNUserNotificationCenter holds it WEAKLY, so ARC would free it the
+/// instant this drops and taps would stop routing. Parked for the app's lifetime. Only ever touched on
+/// the main thread; the Send impl exists purely so it can live in a static.
+struct DelegateHolder(Option<Retained<UNDelegate>>);
+unsafe impl Send for DelegateHolder {}
+static DELEGATE: Mutex<DelegateHolder> = Mutex::new(DelegateHolder(None));
+static DELEGATE_SET: AtomicBool = AtomicBool::new(false);
+
+/// Install the notification-center delegate once (idempotent). Must run on the main thread. Called at
+/// setup (so a cold tap right after launch is captured) and defensively before schedule.
+pub fn ensure_delegate(mtm: MainThreadMarker) {
+    if DELEGATE_SET.swap(true, Ordering::SeqCst) {
+        return;
+    }
+    let delegate: Retained<UNDelegate> = unsafe { msg_send![UNDelegate::alloc(mtm), init] };
+    let center = UNUserNotificationCenter::currentNotificationCenter();
+    center.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));
+    DELEGATE.lock().unwrap().0 = Some(delegate);
+    eprintln!("[notify] UNUserNotificationCenter delegate installed");
+}
+
+/// `notifications.requestPermission` → 'granted' | 'denied'. Replies from the authorization block.
+pub fn request_permission(window: tauri::WebviewWindow, id: String) {
+    let w = window.clone();
+    let fail_id = id.clone();
+    let res = window.run_on_main_thread(move || {
+        let mtm = MainThreadMarker::new().expect("run_on_main_thread guarantees main");
+        ensure_delegate(mtm);
+        let center = UNUserNotificationCenter::currentNotificationCenter();
+        let opts = UNAuthorizationOptions::Alert | UNAuthorizationOptions::Sound | UNAuthorizationOptions::Badge;
+        let cb_window = w.clone();
+        let cb_id = id.clone();
+        let block = RcBlock::new(move |granted: Bool, error: *mut NSError| {
+            if !error.is_null() {
+                eprintln!("[notify] requestAuthorization error: {}", unsafe { (*error).localizedDescription() });
+            }
+            let status = if granted.as_bool() { "granted" } else { "denied" };
+            deliver(&cb_window, &json!({ "v": 1, "id": cb_id, "kind": "response", "result": status }));
+        });
+        center.requestAuthorizationWithOptions_completionHandler(opts, &block);
+    });
+    if let Err(e) = res {
+        deliver(&window, &json!({ "v": 1, "id": fail_id, "kind": "response",
+            "error": { "code": "NATIVE_ERROR", "message": format!("failed to reach main thread: {e}") } }));
+    }
+}
+
+/// `notifications.schedule` — post a local notification after `delaySec` (min 1), carrying an optional
+/// `deepLink` in userInfo. Replies { id } once the request is accepted by the center.
+pub fn schedule(window: tauri::WebviewWindow, id: String, params: Value) {
+    // Kit ScheduleOptions: { id?, title, body?, delaySec?, deepLink? }. `id` (notification id) is a
+    // number in the kit; fall back to a timestamp so each schedule is distinct.
+    let notif_id = params["id"].as_i64().unwrap_or_else(|| {
+        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as i64).unwrap_or(0)
+    });
+    let title = params["title"].as_str().unwrap_or("").to_string();
+    let body = params["body"].as_str().unwrap_or("").to_string();
+    let delay = params["delaySec"].as_f64().unwrap_or(1.0).max(1.0);
+    let deep_link = params["deepLink"].as_str().unwrap_or("").to_string();
+
+    let w = window.clone();
+    let fail_id = id.clone();
+    let res = window.run_on_main_thread(move || {
+        let mtm = MainThreadMarker::new().expect("run_on_main_thread guarantees main");
+        ensure_delegate(mtm);
+        let content = UNMutableNotificationContent::new();
+        content.setTitle(&NSString::from_str(&title));
+        content.setBody(&NSString::from_str(&body));
+        if !deep_link.is_empty() {
+            let dl = NSString::from_str(&deep_link);
+            let user_info = NSDictionary::from_slices(&[ns_string!("deepLink")], &[&*dl]);
+            let _: () = unsafe { msg_send![&*content, setUserInfo: &*user_info] };
+        }
+        let trigger = UNTimeIntervalNotificationTrigger::triggerWithTimeInterval_repeats(delay, false);
+        let ident = NSString::from_str(&format!("appwrap-{notif_id}"));
+        let request = UNNotificationRequest::requestWithIdentifier_content_trigger(
+            &ident,
+            &content,
+            Some(trigger.as_ref()),
+        );
+        let cb_window = w.clone();
+        let cb_id = id.clone();
+        let block = RcBlock::new(move |error: *mut NSError| {
+            if error.is_null() {
+                deliver(&cb_window, &json!({ "v": 1, "id": cb_id, "kind": "response", "result": { "id": notif_id } }));
+            } else {
+                let msg = unsafe { (*error).localizedDescription() }.to_string();
+                eprintln!("[notify] schedule failed: {msg}");
+                deliver(&cb_window, &json!({ "v": 1, "id": cb_id, "kind": "response",
+                    "error": { "code": "NATIVE_ERROR", "message": msg } }));
+            }
+        });
+        let center = UNUserNotificationCenter::currentNotificationCenter();
+        center.addNotificationRequest_withCompletionHandler(&request, Some(&block));
+        eprintln!("[notify] scheduled #{notif_id} in {delay}s{}", if deep_link.is_empty() { String::new() } else { format!(" → {deep_link}") });
+    });
+    if let Err(e) = res {
+        deliver(&window, &json!({ "v": 1, "id": fail_id, "kind": "response",
+            "error": { "code": "NATIVE_ERROR", "message": format!("failed to reach main thread: {e}") } }));
+    }
+}
+
+/// `notifications.pending` → count of scheduled-but-not-delivered notifications.
+pub fn pending(window: tauri::WebviewWindow, id: String) {
+    let w = window.clone();
+    let fail_id = id.clone();
+    let res = window.run_on_main_thread(move || {
+        let center = UNUserNotificationCenter::currentNotificationCenter();
+        let cb_window = w.clone();
+        let cb_id = id.clone();
+        let block = RcBlock::new(move |requests: std::ptr::NonNull<NSArray<UNNotificationRequest>>| {
+            let count = unsafe { requests.as_ref() }.count();
+            deliver(&cb_window, &json!({ "v": 1, "id": cb_id, "kind": "response", "result": count }));
+        });
+        center.getPendingNotificationRequestsWithCompletionHandler(&block);
+    });
+    if let Err(e) = res {
+        deliver(&window, &json!({ "v": 1, "id": fail_id, "kind": "response",
+            "error": { "code": "NATIVE_ERROR", "message": format!("failed to reach main thread: {e}") } }));
+    }
+}

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

@@ -0,0 +1,139 @@
+// macOS `oauth.authorize` — ASWebAuthenticationSession (system-browser auth sheet), exact parity with
+// the iOS shell path in runtime/app/shell/handlers-oauth.ts: the session captures the dynamic
+// `callbackScheme` redirect ITSELF (no Info.plist registration — reversed Google client ids aren't
+// registrable), auto-closes on redirect, and signals user-cancel as error code 1 (CanceledLogin).
+//
+// Threading: everything AS* runs on the main thread (run_on_main_thread). The strong refs to the
+// session + presentation-context provider are parked in a static for the sheet's lifetime — ARC frees
+// them the moment the locals drop otherwise, which silently cancels the flow mid-handshake (same
+// warning as the iOS file).
+use std::sync::atomic::Ordering;
+use std::sync::Mutex;
+
+use objc2::rc::Retained;
+use objc2::runtime::{NSObject, NSObjectProtocol, ProtocolObject};
+use objc2::{define_class, AnyThread, DefinedClass, MainThreadOnly};
+use objc2_authentication_services::{
+    ASPresentationAnchor, ASWebAuthenticationPresentationContextProviding, ASWebAuthenticationSession,
+};
+use objc2_foundation::{NSError, NSString, NSURL};
+use serde_json::json;
+
+use crate::{deliver, deliver_error, OAUTH_IN_FLIGHT};
+
+pub struct ProviderIvars {
+    /// The shell window's NSWindow, retained as NSObject (ASPresentationAnchor aliases NSObject in
+    /// the objc2 bindings; on macOS the real type is NSWindow).
+    anchor: Retained<NSObject>,
+}
+
+define_class!(
+    #[unsafe(super(NSObject))]
+    #[thread_kind = MainThreadOnly]
+    #[name = "AppwrapOAuthContextProvider"]
+    #[ivars = ProviderIvars]
+    struct Provider;
+
+    unsafe impl NSObjectProtocol for Provider {}
+
+    unsafe impl ASWebAuthenticationPresentationContextProviding for Provider {
+        #[unsafe(method_id(presentationAnchorForWebAuthenticationSession:))]
+        fn presentation_anchor(
+            &self,
+            _session: &ASWebAuthenticationSession,
+        ) -> Retained<ASPresentationAnchor> {
+            self.ivars().anchor.clone()
+        }
+    }
+);
+
+/// Strong refs held while the sheet is up. Only ever touched on the main thread — the Send impl
+/// exists purely so the (main-thread-confined) pair can live in a static Mutex.
+struct ActiveFlow(Option<(Retained<ASWebAuthenticationSession>, Retained<Provider>)>);
+unsafe impl Send for ActiveFlow {}
+static ACTIVE: Mutex<ActiveFlow> = Mutex::new(ActiveFlow(None));
+
+/// Kick off the auth session. Caller has already set OAUTH_IN_FLIGHT; every exit path here (start
+/// failure or completion) clears it.
+pub fn start(window: tauri::WebviewWindow, id: String, url: String, scheme: String, ephemeral: bool) {
+    let w = window.clone();
+    let res = window.run_on_main_thread(move || start_on_main(w, id.clone(), &url, &scheme, ephemeral, &id));
+    if let Err(e) = res {
+        OAUTH_IN_FLIGHT.store(false, Ordering::SeqCst);
+        eprintln!("[oauth] failed to reach main thread: {e}");
+    }
+}
+
+fn fail(window: &tauri::WebviewWindow, id: &str, msg: &str) {
+    OAUTH_IN_FLIGHT.store(false, Ordering::SeqCst);
+    deliver_error(window, id, "NATIVE_ERROR", msg);
+}
+
+fn start_on_main(window: tauri::WebviewWindow, id: String, url: &str, scheme: &str, ephemeral: bool, id_ref: &str) {
+    let mtm = objc2::MainThreadMarker::new().expect("run_on_main_thread guarantees main");
+
+    let Some(ns_url) = NSURL::URLWithString(&NSString::from_str(url)) else {
+        return fail(&window, id_ref, "oauth.authorize: invalid url");
+    };
+    let ns_window = match window.ns_window() {
+        Ok(p) if !p.is_null() => p,
+        _ => return fail(&window, id_ref, "oauth.authorize: no native window"),
+    };
+    // Retain the NSWindow (as NSObject) for the provider's lifetime.
+    let anchor: Retained<NSObject> =
+        unsafe { Retained::retain(ns_window as *mut NSObject) }.expect("non-null NSWindow");
+
+    let completion_window = window.clone();
+    let completion_id = id.clone();
+    let block = block2::RcBlock::new(move |cb_url: *mut NSURL, error: *mut NSError| {
+        // Drop the strong refs + the in-flight guard FIRST — a follow-up authorize must be legal
+        // from inside the completion.
+        ACTIVE.lock().unwrap().0 = None;
+        OAUTH_IN_FLIGHT.store(false, Ordering::SeqCst);
+        if !error.is_null() {
+            let err = unsafe { &*error };
+            // ASWebAuthenticationSessionErrorCodeCanceledLogin == 1 → user dismissed the sheet.
+            let code = if err.code() == 1 { "CANCELLED" } else { "NATIVE_ERROR" };
+            let msg = err.localizedDescription().to_string();
+            eprintln!("[oauth] completed with error ({code}): {msg}");
+            deliver_error(&completion_window, &completion_id, code, &msg);
+            return;
+        }
+        let url_str = if cb_url.is_null() {
+            String::new()
+        } else {
+            unsafe { (*cb_url).absoluteString() }.map(|s| s.to_string()).unwrap_or_default()
+        };
+        eprintln!("[oauth] completed: callback url captured");
+        let resp = json!({ "v": 1, "id": completion_id, "kind": "response", "result": { "url": url_str } });
+        deliver(&completion_window, &resp);
+    });
+
+    // The callbackURLScheme initializer is soft-deprecated in favor of the ASWebAuthenticationSession-
+    // Callback variant (macOS 14+); the scheme form works from 10.15 and matches the iOS shell exactly.
+    #[allow(deprecated)]
+    let session = unsafe {
+        ASWebAuthenticationSession::initWithURL_callbackURLScheme_completionHandler(
+            ASWebAuthenticationSession::alloc(),
+            &ns_url,
+            Some(&NSString::from_str(scheme)),
+            &*block as *const _ as *mut _,
+        )
+    };
+
+    let provider = Provider::alloc(mtm).set_ivars(ProviderIvars { anchor });
+    let provider: Retained<Provider> = unsafe { objc2::msg_send![super(provider), init] };
+    unsafe {
+        session.setPresentationContextProvider(Some(ProtocolObject::from_ref(&*provider)));
+        session.setPrefersEphemeralWebBrowserSession(ephemeral);
+    }
+
+    // Park strong refs BEFORE start() — the completion can fire synchronously on failure.
+    ACTIVE.lock().unwrap().0 = Some((session.clone(), provider));
+    let started = unsafe { session.start() };
+    eprintln!("[oauth] session start → {started}");
+    if !started {
+        ACTIVE.lock().unwrap().0 = None;
+        fail(&window, id_ref, "oauth.authorize: session failed to start");
+    }
+}