fix: restore WebSocket streaming in native daemon (#826)

* fix: restore WebSocket streaming in native daemon

The v0.20.0 Rust rewrite broke WebSocket streaming — connections opened
but received zero messages before closing. Multiple issues contributed:

1. StreamServer was dropped immediately after creation in daemon.rs,
   closing the broadcast channel and killing all WS connections.

2. Screencast frames were only processed during command polling
   (drain_cdp_events) instead of in real-time, unlike the 0.19.0
   TypeScript cdp.on('Page.screencastFrame') callback.

3. Auto-start/stop screencast on WS client connect/disconnect was
   missing from the Rust implementation.

4. Screencast CDP commands used the wrong session ID (daemon session
   name instead of the CDP page session from Target.attachToTarget).

5. Broadcast channel Lagged errors killed WS connections instead of
   being handled gracefully.

The fix adds a background CDP event loop in StreamServer that subscribes
to Chrome events and broadcasts screencast frames in real-time, properly
tracks the CDP page session ID, restores auto-screencast lifecycle, and
keeps the StreamServer alive in DaemonState.

Fixes #820

* fix: use actual CDP session ID for input dispatch in stream WebSocket

Pass the real cdp_session_id (from Target.attachToTarget) through to
handle_ws_client instead of an empty string. Previously, input commands
(mouse, keyboard, touch) were sent with `"sessionId": ""` which Chrome
silently rejects. Now the correct page session ID is read at dispatch
time, and when no session ID is set yet (before browser launch),
the field is omitted entirely via `None` so Chrome uses browser-level
dispatch.

---------

Co-authored-by: ctate <366502+ctate@users.noreply.github.com>

cli/src/native/daemon.rs

@@ -40,6 +40,7 @@ pub async fn run_daemon(session: &str) {
     }
 
     let mut stream_client: Option<Arc<RwLock<Option<Arc<CdpClient>>>>> = None;
+    let mut stream_server_instance: Option<Arc<StreamServer>> = None;
     if let Ok(port_str) = env::var("AGENT_BROWSER_STREAM_PORT") {
         if let Ok(port) = port_str.parse::<u16>() {
             if port > 0 {
@@ -51,6 +52,7 @@ pub async fn run_daemon(session: &str) {
                             let _ =
                                 writeln!(std::io::stderr(), "Failed to write .stream file: {}", e);
                         }
+                        stream_server_instance = Some(Arc::new(stream_server));
                     }
                     Err(e) => {
                         let _ = writeln!(std::io::stderr(), "Stream server failed to start: {}", e);
@@ -67,7 +69,14 @@ pub async fn run_daemon(session: &str) {
         .and_then(|s| s.parse::<u64>().ok())
         .filter(|&ms| ms > 0);
 
-    let result = run_socket_server(&socket_path, session, stream_client, idle_timeout_ms).await;
+    let result = run_socket_server(
+        &socket_path,
+        session,
+        stream_client,
+        stream_server_instance,
+        idle_timeout_ms,
+    )
+    .await;
 
     let _ = fs::remove_file(&socket_path);
     let _ = fs::remove_file(&pid_path);
@@ -85,6 +94,7 @@ async fn run_socket_server(
     socket_path: &PathBuf,
     _session: &str,
     stream_client: Option<Arc<RwLock<Option<Arc<CdpClient>>>>>,
+    stream_server: Option<Arc<StreamServer>>,
     idle_timeout_ms: Option<u64>,
 ) -> Result<(), String> {
     use tokio::net::UnixListener;
@@ -93,7 +103,7 @@ async fn run_socket_server(
         UnixListener::bind(socket_path).map_err(|e| format!("Failed to bind socket: {}", e))?;
 
     let state: std::sync::Arc<tokio::sync::Mutex<DaemonState>> = std::sync::Arc::new(
-        tokio::sync::Mutex::new(DaemonState::new_with_stream_client(stream_client)),
+        tokio::sync::Mutex::new(DaemonState::new_with_stream(stream_client, stream_server)),
     );
 
     let (reset_tx, mut reset_rx) = mpsc::channel::<()>(64);
@@ -152,6 +162,7 @@ async fn run_socket_server(
     socket_path: &PathBuf,
     session: &str,
     stream_client: Option<Arc<RwLock<Option<Arc<CdpClient>>>>>,
+    stream_server: Option<Arc<StreamServer>>,
     idle_timeout_ms: Option<u64>,
 ) -> Result<(), String> {
     use tokio::net::TcpListener;
@@ -166,7 +177,7 @@ async fn run_socket_server(
     let _ = fs::write(&port_path, port.to_string());
 
     let state: std::sync::Arc<tokio::sync::Mutex<DaemonState>> = std::sync::Arc::new(
-        tokio::sync::Mutex::new(DaemonState::new_with_stream_client(stream_client)),
+        tokio::sync::Mutex::new(DaemonState::new_with_stream(stream_client, stream_server)),
     );
 
     let (reset_tx, mut reset_rx) = mpsc::channel::<()>(64);