@livx.cc/appwrap 0.43.0 → 0.46.2

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

@@ -16,6 +16,9 @@ use tauri::Manager;
 #[cfg(target_os = "macos")]
 mod biometrics_mac;
 #[cfg(target_os = "macos")]
+mod bridge_mac;
+mod browser_tab;
+#[cfg(target_os = "macos")]
 mod notifications_mac;
 #[cfg(target_os = "macos")]
 mod oauth_mac;
@@ -24,6 +27,8 @@ mod popup_mac;
 #[cfg(target_os = "macos")]
 mod push_mac;
 #[cfg(target_os = "macos")]
+mod server;
+#[cfg(target_os = "macos")]
 mod sidecar;
 
 static STORAGE: Mutex<Option<HashMap<String, String>>> = Mutex::new(None);
@@ -46,6 +51,26 @@ static OAUTH_IN_FLIGHT: AtomicBool = AtomicBool::new(false);
 struct DeepLinkState { handshaken: bool, pending: Option<String> }
 static DEEPLINK: Mutex<DeepLinkState> = Mutex::new(DeepLinkState { handshaken: false, pending: None });
 
+/// Server-mode (`desktop.server`) deep-link delivery. The page is a plain web app (not a native-kit
+/// consumer), so instead of the native `deeplink.open` handshake we deliver deep links to it directly:
+/// COLD (link arrived before the page loaded) → appended to the navigation URL as `?__appwrap_deeplink=`
+/// so the page reads it on first load; WARM (already loaded) → a `window` CustomEvent `appwrap:deeplink`.
+/// `loaded` flips true when the boot thread navigates to the server URL (drains `pending` atomically).
+struct ServerNav { loaded: bool, pending: Option<String> }
+static SERVER_NAV: Mutex<ServerNav> = Mutex::new(ServerNav { loaded: false, pending: None });
+
+/// Percent-encode a string for use as a URL query-param value (RFC3986 unreserved set kept verbatim).
+fn percent_encode(s: &str) -> String {
+    let mut out = String::new();
+    for b in s.bytes() {
+        match b {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => out.push(b as char),
+            _ => out.push_str(&format!("%{b:02X}")),
+        }
+    }
+    out
+}
+
 /// App identity + window shape, stamped by `appwrap dev|build desktop` from the appwrap config into
 /// `shell_config.json` (embedded at compile time). De-hardcodes what the spike baked in. Mirrors
 /// `DesktopShellConfig` in packages/appwrap-cli/src/desktop.ts.
@@ -87,6 +112,40 @@ struct ShellConfig {
     /// actually succeed. Gates push.register and the handshake's push capability (adhoc → 'none').
     #[serde(default)]
     push_signed: bool,
+    /// Local-server mode: when present the shell boots this command, waits for its port, then
+    /// navigates the window to `http://localhost:<port>` (instead of loading the bundled dist), and
+    /// SIGTERMs its process group on close. Absent → bundled-PWA load. See server.rs.
+    #[serde(default)]
+    server: Option<ServerConfig>,
+}
+
+/// Resolved local-server config (mirrors `DesktopShellConfig.server` in desktop.ts; `command`/`cwd`/
+/// `path` are absolute, stamped by the CLI).
+#[derive(serde::Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+struct ServerConfig {
+    command: String,
+    #[serde(default)]
+    args: Vec<String>,
+    #[serde(default)]
+    cwd: String,
+    /// Non-empty → capture the URL the server prints on the first stdout line containing this marker
+    /// (tracks a dynamic port). Empty → use the fixed `port` below.
+    #[serde(default)]
+    url_marker: String,
+    #[serde(default)]
+    port: u16,
+    /// Load over https (vs http) in fixed-`port` mode. True when the server serves TLS (e.g. vite + mkcert).
+    #[serde(default)]
+    https: bool,
+    /// Reserved: readiness currently uses a TCP-accept probe (sufficient for vite/preview), so the
+    /// path isn't hit yet — kept in the wire config for a future HTTP health probe.
+    #[serde(default)]
+    #[allow(dead_code)]
+    health_path: String,
+    ready_timeout_ms: u64,
+    #[serde(default)]
+    path: String,
 }
 
 fn default_true() -> bool { true }
@@ -108,6 +167,20 @@ const INIT_JS: &str = r#"
 })();
 "#;
 
+/// Build a JS snippet that swaps the boot splash into an error state with `msg` (server mode). Escapes
+/// the message for a single-quoted JS string literal.
+fn splash_error_js(msg: &str) -> String {
+    let esc = msg
+        .replace('\\', "\\\\")
+        .replace('\'', "\\'")
+        .replace(['\n', '\r'], " ");
+    format!(
+        "(function(){{var s=document.getElementById('spin');if(s)s.remove();\
+var m=document.getElementById('m');if(m)m.textContent='Server didn\\'t start';\
+var e=document.getElementById('e');if(e)e.textContent='{esc}';}})()"
+    )
+}
+
 type HandlerResult = Result<Value, (&'static str, String)>;
 
 /// spawn() without wait() leaks a zombie per call; reap in a detached thread.
@@ -548,6 +621,28 @@ fn deliver_error(window: &tauri::WebviewWindow, id: &str, code: &str, message: &
 /// response so the PWA routes before first paint). Reaches the main window via the stashed AppHandle,
 /// so it's safe to call from any thread. DRY single source for both entry points.
 pub fn route_deeplink(url: &str) {
+    // Server-mode apps get direct web delivery (see ServerNav), not the native-kit handshake path.
+    #[cfg(target_os = "macos")]
+    if shell().server.is_some() {
+        let deliver_now = {
+            let mut nav = SERVER_NAV.lock().unwrap();
+            if nav.loaded {
+                true
+            } else {
+                nav.pending = Some(url.to_string()); // cold → boot thread appends to the nav URL
+                false
+            }
+        };
+        if deliver_now {
+            if let Some(window) = APP.get().and_then(|app| app.get_webview_window("main")) {
+                let esc = url.replace('\\', "\\\\").replace('\'', "\\'");
+                let _ = window.eval(&format!(
+                    "window.dispatchEvent(new CustomEvent('appwrap:deeplink',{{detail:'{esc}'}}))"
+                ));
+            }
+        }
+        return;
+    }
     let warm = {
         let mut dl = DEEPLINK.lock().unwrap();
         if !dl.handshaken && dl.pending.is_none() {
@@ -594,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).
@@ -606,11 +707,16 @@ fn main() {
                 popup_mac::close_all();
                 // Kill the handlers sidecar so the Bun process never outlives the shell.
                 sidecar::shutdown();
+                // NB: server teardown runs on RunEvent::Exit (below), NOT here — a blocking kill in
+                // this close handler would starve tauri-plugin-window-state's own save-on-close.
             }
         })
         .setup(|app| {
             // Stash the app handle so off-main-thread handlers can reach plugin state (notifications).
             let _ = APP.set(app.handle().clone());
+            // SPIKE: browser-bridge window-ops backend — inert unless APPWRAP_BRIDGE_JS is set.
+            #[cfg(target_os = "macos")]
+            bridge_mac::init(app.handle().clone());
             // Per-app custom handlers: spawn the Bun sidecar when configured (absolute path stamped by
             // the CLI). No-op / degrades to inert when empty, on spawn failure, or on a missing `ready`.
             // NOTE: init blocks setup for up to READY_TIMEOUT (5s, bounded) — intentional: sidecar
@@ -657,6 +763,64 @@ fn main() {
                     let _ = window.show();
                 }
             }
+            // Local-server mode: boot the server child now (the window shows the bundled splash), then a
+            // background thread polls its port and navigates the window to it — or, on timeout/spawn
+            // failure, writes the reason into the splash. Absent `server` → the bundled dist just loads.
+            #[cfg(target_os = "macos")]
+            if let Some(sc) = shell().server.clone() {
+                match server::spawn(&server::ServerCfg {
+                    command: &sc.command,
+                    args: &sc.args,
+                    cwd: &sc.cwd,
+                    path: &sc.path,
+                    url_marker: &sc.url_marker,
+                }) {
+                    Ok(url_rx) => {
+                        let app_handle = app.handle().clone();
+                        std::thread::spawn(move || {
+                            let timeout = std::time::Duration::from_millis(sc.ready_timeout_ms);
+                            // urlMarker mode → the captured URL (dynamic port); else TCP-poll the fixed port.
+                            let url = match url_rx {
+                                Some(rx) => rx.recv_timeout(timeout).ok(),
+                                None => server::wait_for_port(sc.port, sc.ready_timeout_ms)
+                                    .then(|| format!("{}://localhost:{}", if sc.https { "https" } else { "http" }, sc.port)),
+                            };
+                            let Some(win) = app_handle.get_webview_window("main") else { return };
+                            match url {
+                                Some(u) => {
+                                    // Flip to loaded + drain any cold deep link together, so a link
+                                    // arriving now either lands in this URL or takes the warm path.
+                                    let cold = {
+                                        let mut nav = SERVER_NAV.lock().unwrap();
+                                        nav.loaded = true;
+                                        nav.pending.take()
+                                    };
+                                    let target = match cold {
+                                        Some(dl) => {
+                                            let sep = if u.contains('?') { '&' } else { '?' };
+                                            format!("{u}{sep}__appwrap_deeplink={}", percent_encode(&dl))
+                                        }
+                                        None => u,
+                                    };
+                                    let _ = win.eval(&format!("location.replace('{target}')"));
+                                }
+                                None => {
+                                    let _ = win.eval(&splash_error_js(&format!(
+                                        "Server didn't come up within {}s.",
+                                        sc.ready_timeout_ms / 1000
+                                    )));
+                                }
+                            }
+                        });
+                    }
+                    Err(e) => {
+                        eprintln!("[server] spawn `{}` failed: {e} — server mode inert", sc.command);
+                        if let Some(win) = app.get_webview_window("main") {
+                            let _ = win.eval(&splash_error_js(&format!("Failed to start server: {e}")));
+                        }
+                    }
+                }
+            }
             // OS deep links (<urlScheme>://…, registered via the .app's CFBundleURLTypes). Warm →
             // emit `deeplink.open` (same envelope as the internal loopback in appwrap_invoke);
             // pre-handshake → stash the FIRST url, carried back in the handshake response.
@@ -670,6 +834,16 @@ fn main() {
                     route_deeplink(&url);
                 }
             });
+            // Cold launch: the URL that LAUNCHED the app (open para://…) can be missed by on_open_url on
+            // macOS — retrieve it explicitly so a link that starts the app is honored too. Stashed as a
+            // cold deep link (server mode → drained into the boot navigation; see route_deeplink/ServerNav).
+            if let Ok(Some(urls)) = app.deep_link().get_current() {
+                for url in urls {
+                    let url = url.to_string();
+                    eprintln!("[bridge] deeplink.open (launch) ← {url}");
+                    route_deeplink(&url);
+                }
+            }
             // Install the UNUserNotificationCenter delegate now (main thread) so a notification tapped
             // right after a cold launch is captured. Idempotent with the schedule-time call.
             #[cfg(target_os = "macos")]
@@ -678,6 +852,35 @@ fn main() {
             }
             Ok(())
         })
-        .run(tauri::generate_context!())
-        .expect("error while running appwrap desktop shell");
+        .build(tauri::generate_context!())
+        .expect("error while building appwrap desktop shell")
+        .run(|app_handle, event| {
+            #[cfg(target_os = "macos")]
+            match &event {
+                // ExitRequested fires while the window still EXISTS (⌘Q / Dock-quit / last-window-close),
+                // so persist geometry here — the window-state plugin's own save only fires on window
+                // CLOSE events, which those quit paths skip, so position/size wouldn't restore next run.
+                tauri::RunEvent::ExitRequested { .. } => {
+                    if shell().restore_window_state {
+                        use tauri_plugin_window_state::{AppHandleExt, StateFlags};
+                        let _ = app_handle.save_window_state(StateFlags::all());
+                    }
+                    server::shutdown();
+                }
+                // Belt-and-suspenders: also tear down on Exit (idempotent — shutdown() takes the child
+                // out of its slot, so this is a no-op after ExitRequested already ran).
+                tauri::RunEvent::Exit => server::shutdown(),
+                // macOS URL-scheme delivery for BOTH cold launch (app opened BY the link) and warm
+                // re-open — the canonical path; `on_open_url`/`get_current` miss the launch URL. Routed
+                // through the same handler (server mode → drained into the boot nav or dispatched warm).
+                tauri::RunEvent::Opened { urls } => {
+                    for url in urls {
+                        let u = url.to_string();
+                        eprintln!("[bridge] deeplink.open (opened) ← {u}");
+                        route_deeplink(&u);
+                    }
+                }
+                _ => {}
+            }
+        });
 }