perf(tauri): Rust-native desktop event transport (#242)

## Summary

- switch the Tauri desktop runtime from the browser `EventSource` path
to a native Rust desktop event transport while leaving browser and
Electron unchanged
- restore SSE heartbeat parity by parsing named `event:` frames and
replying to `codenomad.client.ping` with an authenticated
`/api/client-connections/pong`
- add a Tauri-only settings toggle that lets the current device fall
back to the browser `EventSource` transport without leaking that choice
through shared config
- remove the temporary benchmark harness from the shipped code now that
the transport behavior has been validated

## Benchmark

The temporary in-app benchmark harness used during validation has been
removed from the final code, but the measured results are retained here
for review context.

Real Tauri/WebView2 benchmark on Windows using the dedicated session:
- workspace: `D:\CodeNomad`
- session: `ses_21feb15b3ffeLz3uRModK4KKnG`

Short command:
- `node -e "for (let i = 1; i <= 400; i += 1) console.log('line ' + i)"`

Results:
- browser `EventSource` forced in Tauri:
  - timed out after `131479.7ms`
  - `sawWorking=false`
  - `reachedIdle=false`
  - `batchesReceived=84`
  - `eventsReceived=84`
  - `maxBatchSize=1`
- Rust-native transport:
  - completed in `1437.4ms`
  - `sawWorking=true`
  - `reachedIdle=true`
  - `batchesReceived=4`
  - `eventsReceived=45`
  - `maxBatchSize=27`

Long heartbeat / stale-timeout validation:
- command: `powershell -NoProfile -Command Start-Sleep -Seconds 70`
- Rust-native transport:
  - completed in `71689.5ms`
  - `sawWorking=true`
  - `reachedIdle=true`
  - `batchesReceived=13`
  - `eventsReceived=72`
  - `maxBatchSize=25`

Confirmed separately afterward: the native transport also behaves better
on Linux.

## Validation

- `cargo test named_ping_event_is_routed_to_ping_channel`
- `cargo test session_cookie_is_attached_to_requests`
- `cargo test --no-run`
- `npx tsc --noEmit --pretty -p packages/ui/tsconfig.json`
- `npx tsc --noEmit --pretty -p packages/server/tsconfig.json`
- manual Tauri/WebView2 benchmark on Windows
- manual confirmation on Linux after the benchmark phase

## Notes

- this remains a Tauri-only transport; browser and Electron stay on the
browser `EventSource` path
- the Tauri fallback toggle is now genuinely device-local and restarts
the local event stream immediately when changed
- the long run validates heartbeat / stale-timeout robustness, not
headline perf

Author: pascalandr

packages/tauri-app/src-tauri/src/cli_manager.rs

@@ -1,3 +1,4 @@
+use crate::desktop_event_transport::DesktopEventStreamConfig;
 use crate::managed_node::resolve_bundled_node_binary;
 use dirs::home_dir;
 use parking_lot::Mutex;
@@ -185,12 +186,13 @@ fn kill_process_tree_windows(pid: u32, force: bool) -> bool {
 }
 fn navigate_main(app: &AppHandle, url: &str) {
     if let Some(win) = app.webview_windows().get("main") {
-        let mut display = url.to_string();
+        let final_url = augment_launch_url(url);
+        let mut display = final_url.clone();
         if let Some(hash_index) = display.find('#') {
             display.replace_range(hash_index + 1.., "[REDACTED]");
         }
         log_line(&format!("navigating main to {display}"));
-        if let Ok(parsed) = Url::parse(url) {
+        if let Ok(parsed) = Url::parse(&final_url) {
             let _ = win.navigate(parsed);
         } else {
             log_line("failed to parse URL for navigation");
@@ -200,6 +202,31 @@ fn navigate_main(app: &AppHandle, url: &str) {
     }
 }
 
+fn augment_launch_url(base_url: &str) -> String {
+    let launch_query = std::env::var("CODENOMAD_UI_LAUNCH_QUERY")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty());
+
+    let Some(launch_query) = launch_query else {
+        return base_url.to_string();
+    };
+
+    if base_url.contains('?') {
+        return format!(
+            "{}&{}",
+            base_url,
+            launch_query.trim_start_matches(['?', '#'])
+        );
+    }
+
+    format!(
+        "{}?{}",
+        base_url,
+        launch_query.trim_start_matches(['?', '#'])
+    )
+}
+
 fn extract_cookie_value(set_cookie: &str, name: &str) -> Option<String> {
     let prefix = format!("{name}=");
     let cookie_kv = set_cookie.split(';').next()?.trim();
@@ -298,6 +325,15 @@ fn generate_auth_cookie_name() -> String {
     format!("{SESSION_COOKIE_NAME_PREFIX}_{pid}_{timestamp}")
 }
 
+fn generate_transport_connection_id() -> String {
+    let ts = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis();
+    let tid = std::thread::current().id();
+    format!("tauri-{}-{:?}", ts, tid)
+}
+
 const DEFAULT_CONFIG_PATH: &str = "~/.config/codenomad/config.json";
 
 #[derive(Debug, Deserialize)]
@@ -456,6 +492,8 @@ pub struct CliProcessManager {
     job: Arc<Mutex<Option<WindowsJobObject>>>,
     ready: Arc<AtomicBool>,
     bootstrap_token: Arc<Mutex<Option<String>>>,
+    session_cookie: Arc<Mutex<Option<String>>>,
+    auth_cookie_name: Arc<Mutex<Option<String>>>,
 }
 
 impl CliProcessManager {
@@ -467,6 +505,8 @@ impl CliProcessManager {
             job: Arc::new(Mutex::new(None)),
             ready: Arc::new(AtomicBool::new(false)),
             bootstrap_token: Arc::new(Mutex::new(None)),
+            session_cookie: Arc::new(Mutex::new(None)),
+            auth_cookie_name: Arc::new(Mutex::new(None)),
         }
     }
 
@@ -475,6 +515,8 @@ impl CliProcessManager {
         self.stop()?;
         self.ready.store(false, Ordering::SeqCst);
         *self.bootstrap_token.lock() = None;
+        *self.session_cookie.lock() = None;
+        *self.auth_cookie_name.lock() = None;
         {
             let mut status = self.status.lock();
             status.state = CliState::Starting;
@@ -491,6 +533,8 @@ impl CliProcessManager {
         let job_arc = self.job.clone();
         let ready_flag = self.ready.clone();
         let token_arc = self.bootstrap_token.clone();
+        let session_cookie_arc = self.session_cookie.clone();
+        let auth_cookie_name_arc = self.auth_cookie_name.clone();
         thread::spawn(move || {
             if let Err(err) = Self::spawn_cli(
                 app.clone(),
@@ -500,6 +544,8 @@ impl CliProcessManager {
                 job_arc,
                 ready_flag,
                 token_arc,
+                session_cookie_arc,
+                auth_cookie_name_arc,
                 dev,
             ) {
                 log_line(&format!("cli spawn failed: {err}"));
@@ -594,6 +640,7 @@ impl CliProcessManager {
         status.port = None;
         status.url = None;
         status.error = None;
+        *self.session_cookie.lock() = None;
 
         Ok(())
     }
@@ -602,13 +649,35 @@ impl CliProcessManager {
         self.status.lock().clone()
     }
 
+    pub fn desktop_event_stream_config(&self) -> Option<DesktopEventStreamConfig> {
+        let base_url = self.status.lock().url.clone()?;
+        let events_url = format!("{}/api/events", base_url.trim_end_matches('/'));
+        let client_id = format!("tauri-{}", std::process::id());
+        let cookie_name = self
+            .auth_cookie_name
+            .lock()
+            .clone()
+            .unwrap_or_else(|| SESSION_COOKIE_NAME_PREFIX.to_string());
+
+        Some(DesktopEventStreamConfig {
+            base_url,
+            events_url,
+            client_id,
+            connection_id: generate_transport_connection_id(),
+            cookie_name,
+            session_cookie: self.session_cookie.lock().clone(),
+        })
+    }
+
     fn spawn_cli(
         app: AppHandle,
         status: Arc<Mutex<CliStatus>>,
         child_holder: Arc<Mutex<Option<Child>>>,
         #[cfg(windows)] job_holder: Arc<Mutex<Option<WindowsJobObject>>>,
         ready: Arc<AtomicBool>,
         bootstrap_token: Arc<Mutex<Option<String>>>,
+        session_cookie: Arc<Mutex<Option<String>>>,
+        auth_cookie_name_holder: Arc<Mutex<Option<String>>>,
         dev: bool,
     ) -> anyhow::Result<()> {
         log_line("resolving CLI entry");
@@ -619,6 +688,7 @@ impl CliProcessManager {
             resolution.runner, resolution.entry, host
         ));
         let auth_cookie_name = Arc::new(generate_auth_cookie_name());
+        *auth_cookie_name_holder.lock() = Some(auth_cookie_name.as_str().to_string());
         let args = resolution.build_args(dev, &host, auth_cookie_name.as_str());
         log_line(&format!("CLI args: {:?}", args));
         if dev {
@@ -723,6 +793,7 @@ impl CliProcessManager {
         let app_clone = app.clone();
         let ready_clone = ready.clone();
         let token_clone = bootstrap_token.clone();
+        let session_cookie_clone = session_cookie.clone();
         let auth_cookie_name_clone = auth_cookie_name.clone();
 
         thread::spawn(move || {
@@ -742,6 +813,7 @@ impl CliProcessManager {
                 let status = status_clone.clone();
                 let ready = ready_clone.clone();
                 let token = token_clone.clone();
+                let session_cookie = session_cookie_clone.clone();
                 let auth_cookie_name = auth_cookie_name_clone.clone();
                 thread::spawn(move || {
                     Self::process_stream(
@@ -751,6 +823,7 @@ impl CliProcessManager {
                         &status,
                         &ready,
                         &token,
+                        &session_cookie,
                         auth_cookie_name.as_str(),
                     );
                 });
@@ -761,6 +834,7 @@ impl CliProcessManager {
                 let status = status_clone.clone();
                 let ready = ready_clone.clone();
                 let token = token_clone.clone();
+                let session_cookie = session_cookie_clone.clone();
                 let auth_cookie_name = auth_cookie_name_clone.clone();
                 thread::spawn(move || {
                     Self::process_stream(
@@ -770,6 +844,7 @@ impl CliProcessManager {
                         &status,
                         &ready,
                         &token,
+                        &session_cookie,
                         auth_cookie_name.as_str(),
                     );
                 });
@@ -894,6 +969,7 @@ impl CliProcessManager {
         status: &Arc<Mutex<CliStatus>>,
         ready: &Arc<AtomicBool>,
         bootstrap_token: &Arc<Mutex<Option<String>>>,
+        session_cookie: &Arc<Mutex<Option<String>>>,
         auth_cookie_name: &str,
     ) {
         let mut buffer = String::new();
@@ -946,6 +1022,7 @@ impl CliProcessManager {
                                 status,
                                 ready,
                                 bootstrap_token,
+                                session_cookie,
                                 auth_cookie_name,
                                 url,
                             );
@@ -963,6 +1040,7 @@ impl CliProcessManager {
         status: &Arc<Mutex<CliStatus>>,
         ready: &Arc<AtomicBool>,
         bootstrap_token: &Arc<Mutex<Option<String>>>,
+        session_cookie: &Arc<Mutex<Option<String>>>,
         auth_cookie_name: &str,
         base_url: String,
     ) {
@@ -995,6 +1073,7 @@ impl CliProcessManager {
                             log_line(&format!("failed to set session cookie: {err}"));
                             navigate_main(app, &format!("{base_url}/login"));
                         } else {
+                            *session_cookie.lock() = Some(session_id.clone());
                             navigate_main(app, &base_url);
                         }
                     }
@@ -1215,31 +1294,37 @@ fn resolve_dev_entry(_app: &AppHandle) -> Option<String> {
 }
 
 fn resolve_prod_entry(_app: &AppHandle) -> Option<String> {
+    let base = workspace_root();
+    let exe_dir = std::env::current_exe()
+        .ok()
+        .and_then(|exe| exe.parent().map(|dir| dir.to_path_buf()));
+
+    first_existing(prod_entry_candidates(exe_dir, base))
+}
+
+fn prod_entry_candidates(
+    exe_dir: Option<PathBuf>,
+    workspace: Option<PathBuf>,
+) -> Vec<Option<PathBuf>> {
     let mut candidates = Vec::new();
 
-    if let Ok(exe) = std::env::current_exe() {
-        if let Some(dir) = exe.parent() {
-            candidates.push(Some(dir.join("resources/server/dist/bin.js")));
+    if let Some(dir) = exe_dir {
+        candidates.push(Some(dir.join("resources/server/dist/bin.js")));
 
-            let resources = dir.join("../Resources");
-            candidates.push(Some(resources.join("server/dist/bin.js")));
-            candidates.push(Some(resources.join("resources/server/dist/bin.js")));
+        let resources = dir.join("../Resources");
+        candidates.push(Some(resources.join("server/dist/bin.js")));
+        candidates.push(Some(resources.join("resources/server/dist/bin.js")));
 
-            let linux_resource_roots = [dir.join("../lib/CodeNomad"), dir.join("../lib/codenomad")];
-            for root in linux_resource_roots {
-                candidates.push(Some(root.join("server/dist/bin.js")));
-                candidates.push(Some(root.join("resources/server/dist/bin.js")));
-            }
+        let linux_resource_roots = [dir.join("../lib/CodeNomad"), dir.join("../lib/codenomad")];
+        for root in linux_resource_roots {
+            candidates.push(Some(root.join("server/dist/bin.js")));
+            candidates.push(Some(root.join("resources/server/dist/bin.js")));
         }
     }
 
-    let base = workspace_root();
-    candidates.push(
-        base.as_ref()
-            .map(|p| p.join("packages/server/dist/bin.js")),
-    );
+    candidates.push(workspace.map(|p| p.join("packages/server/dist/bin.js")));
 
-    first_existing(candidates)
+    candidates
 }
 
 fn build_shell_command_string(
@@ -1355,3 +1440,53 @@ fn normalize_path(path: PathBuf) -> String {
         rendered
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex as StdMutex;
+
+    static ENV_LOCK: StdMutex<()> = StdMutex::new(());
+
+    #[test]
+    fn prod_entry_candidates_prefer_exe_relative_before_workspace_fallback() {
+        let exe_dir = PathBuf::from("/opt/codenomad/bin");
+        let workspace = PathBuf::from("/workspace/codenomad");
+
+        let candidates = prod_entry_candidates(Some(exe_dir.clone()), Some(workspace.clone()))
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+
+        assert_eq!(
+            candidates.first(),
+            Some(&exe_dir.join("resources/server/dist/bin.js"))
+        );
+        assert_eq!(
+            candidates.last(),
+            Some(&workspace.join("packages/server/dist/bin.js"))
+        );
+    }
+
+    #[test]
+    fn augment_launch_url_trims_leading_fragment_marker() {
+        let _guard = ENV_LOCK.lock().expect("env lock poisoned");
+        std::env::set_var("CODENOMAD_UI_LAUNCH_QUERY", "#debug=true");
+
+        let augmented = augment_launch_url("http://127.0.0.1:3000");
+
+        std::env::remove_var("CODENOMAD_UI_LAUNCH_QUERY");
+        assert_eq!(augmented, "http://127.0.0.1:3000?debug=true");
+    }
+
+    #[test]
+    fn augment_launch_url_trims_fragment_marker_when_query_exists() {
+        let _guard = ENV_LOCK.lock().expect("env lock poisoned");
+        std::env::set_var("CODENOMAD_UI_LAUNCH_QUERY", "#debug=true");
+
+        let augmented = augment_launch_url("http://127.0.0.1:3000?existing=true");
+
+        std::env::remove_var("CODENOMAD_UI_LAUNCH_QUERY");
+        assert_eq!(augmented, "http://127.0.0.1:3000?existing=true&debug=true");
+    }
+}