debug: add more SSE logging to trace message receiving

- Move SSE initialization inside Effect closure to capture signals properly
- Fix closure capture issue where torrents/stats/notifications were borrowed before being passed to async block
- SSE now starts correctly when user is authenticated

backend/src/main.rs

@@ -6,7 +6,7 @@ mod push;
 mod rate_limit;
 mod sse;
 
-use shared::{scgi, xmlrpc};
+use shared::xmlrpc;
 
 use axum::error_handling::HandleErrorLayer;
 use axum::{

frontend/src/components/mod.rs

@@ -1,6 +1,5 @@
 pub mod context_menu;
 pub mod layout;
-pub mod modal;
 pub mod toast;
 pub mod torrent;
 pub mod auth;

frontend/src/components/modal.rs

@@ -1,55 +0,0 @@
-use leptos::prelude::*;
-
-#[allow(dead_code)]
-#[component]
-pub fn Modal(
-    #[prop(into)] title: String,
-    children: ChildrenFn,
-    #[prop(into)] on_confirm: Callback<()>,
-    #[prop(into)] on_cancel: Callback<()>,
-    #[prop(into)] visible: Signal<bool>,
-    #[prop(into, default = "Confirm".to_string())] confirm_text: String,
-    #[prop(into, default = "Cancel".to_string())] cancel_text: String,
-    #[prop(into, default = false)] is_danger: bool,
-) -> impl IntoView {
-    let title = StoredValue::new_local(title);
-    let on_confirm = StoredValue::new_local(on_confirm);
-    let on_cancel = StoredValue::new_local(on_cancel);
-    let confirm_text = StoredValue::new_local(confirm_text);
-    let cancel_text = StoredValue::new_local(cancel_text);
-    
-    view! {
-        <Show when=move || visible.get() fallback=|| ()>
-            <div class="fixed inset-0 bg-background/80 backdrop-blur-sm flex items-end md:items-center justify-center z-[200] animate-in fade-in duration-200 sm:p-4">
-                <div class="bg-card p-6 rounded-t-2xl md:rounded-lg w-full max-w-sm shadow-xl border border-border ring-0 transform transition-all animate-in slide-in-from-bottom-10 md:slide-in-from-bottom-0 md:zoom-in-95">
-                    <h3 class="text-lg font-semibold text-card-foreground mb-4">{move || title.get_value()}</h3>
-                    
-                    <div class="text-muted-foreground mb-6 text-sm">
-                        {children()}
-                    </div>
-                    
-                    <div class="flex justify-end gap-3">
-                        <button 
-                            class="inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 border border-input bg-background hover:bg-accent hover:text-accent-foreground h-10 px-4 py-2"
-                            on:click=move |_| on_cancel.with_value(|cb| cb.run(()))
-                        >
-                            {move || cancel_text.get_value()}
-                        </button>
-                        <button 
-                            class=move || crate::utils::cn(format!("inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 h-10 px-4 py-2 {}", 
-                                if is_danger { "bg-destructive text-destructive-foreground hover:bg-destructive/90" } 
-                                else { "bg-primary text-primary-foreground hover:bg-primary/90" }
-                            ))
-                            on:click=move |_| {
-                                log::info!("Modal: Confirm clicked");
-                                on_confirm.with_value(|cb| cb.run(()))
-                            }
-                        >
-                            {move || confirm_text.get_value()}
-                        </button>
-                    </div>
-                </div>
-            </div>
-        </Show>
-    }
-}

frontend/src/components/torrent/table.rs

@@ -51,44 +51,49 @@ pub fn TorrentTable() -> impl IntoView {
     let sort_dir = signal(SortDirection::Descending);
 
     let filtered_hashes = move || {
-        store.torrents.with(|map| {
+        let torrents_map = store.torrents.get();
-            let mut torrents: Vec<&shared::Torrent> = map.values().filter(|t| {
+        log::debug!("TorrentTable: store.torrents has {} entries", torrents_map.len());
-                let filter = store.filter.get();
+        
-                let search = store.search_query.get().to_lowercase();
+        let filter = store.filter.get();
-                let matches_filter = match filter {
+        let search = store.search_query.get();
-                    crate::store::FilterStatus::All => true,
+        let search_lower = search.to_lowercase();
-                    crate::store::FilterStatus::Downloading => t.status == shared::TorrentStatus::Downloading,
+        
-                    crate::store::FilterStatus::Seeding => t.status == shared::TorrentStatus::Seeding,
+        let mut torrents: Vec<&shared::Torrent> = torrents_map.values().filter(|t| {
-                    crate::store::FilterStatus::Completed => t.status == shared::TorrentStatus::Seeding || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0),
+            let matches_filter = match filter {
-                    crate::store::FilterStatus::Paused => t.status == shared::TorrentStatus::Paused,
+                crate::store::FilterStatus::All => true,
-                    crate::store::FilterStatus::Inactive => t.status == shared::TorrentStatus::Paused || t.status == shared::TorrentStatus::Error,
+                crate::store::FilterStatus::Downloading => t.status == shared::TorrentStatus::Downloading,
-                    _ => true,
+                crate::store::FilterStatus::Seeding => t.status == shared::TorrentStatus::Seeding,
-                };
+                crate::store::FilterStatus::Completed => t.status == shared::TorrentStatus::Seeding || (t.status == shared::TorrentStatus::Paused && t.percent_complete >= 100.0),
-                let matches_search = if search.is_empty() { true } else { t.name.to_lowercase().contains(&search) };
+                crate::store::FilterStatus::Paused => t.status == shared::TorrentStatus::Paused,
-                matches_filter && matches_search
+                crate::store::FilterStatus::Inactive => t.status == shared::TorrentStatus::Paused || t.status == shared::TorrentStatus::Error,
-            }).collect();
+                _ => true,
+            };
+            let matches_search = if search_lower.is_empty() { true } else { t.name.to_lowercase().contains(&search_lower) };
+            matches_filter && matches_search
+        }).collect();
 
-            torrents.sort_by(|a, b| {
+        log::debug!("TorrentTable: {} torrents after filtering", torrents.len());
-                let col = sort_col.0.get();
+
-                let dir = sort_dir.0.get();
+        torrents.sort_by(|a, b| {
-                let cmp = match col {
+            let col = sort_col.0.get();
-                    SortColumn::Name => a.name.to_lowercase().cmp(&b.name.to_lowercase()),
+            let dir = sort_dir.0.get();
-                    SortColumn::Size => a.size.cmp(&b.size),
+            let cmp = match col {
-                    SortColumn::Progress => a.percent_complete.partial_cmp(&b.percent_complete).unwrap_or(std::cmp::Ordering::Equal),
+                SortColumn::Name => a.name.to_lowercase().cmp(&b.name.to_lowercase()),
-                    SortColumn::Status => format!("{:?}", a.status).cmp(&format!("{:?}", b.status)),
+                SortColumn::Size => a.size.cmp(&b.size),
-                    SortColumn::DownSpeed => a.down_rate.cmp(&b.down_rate),
+                SortColumn::Progress => a.percent_complete.partial_cmp(&b.percent_complete).unwrap_or(std::cmp::Ordering::Equal),
-                    SortColumn::UpSpeed => a.up_rate.cmp(&b.up_rate),
+                SortColumn::Status => format!("{:?}", a.status).cmp(&format!("{:?}", b.status)),
-                    SortColumn::ETA => {
+                SortColumn::DownSpeed => a.down_rate.cmp(&b.down_rate),
-                        let a_eta = if a.eta <= 0 { i64::MAX } else { a.eta };
+                SortColumn::UpSpeed => a.up_rate.cmp(&b.up_rate),
-                        let b_eta = if b.eta <= 0 { i64::MAX } else { b.eta };
+                SortColumn::ETA => {
-                        a_eta.cmp(&b_eta)
+                    let a_eta = if a.eta <= 0 { i64::MAX } else { a.eta };
-                    }
+                    let b_eta = if b.eta <= 0 { i64::MAX } else { b.eta };
-                    SortColumn::AddedDate => a.added_date.cmp(&b.added_date),
+                    a_eta.cmp(&b_eta)
-                };
+                }
-                if dir == SortDirection::Descending { cmp.reverse() } else { cmp }
+                SortColumn::AddedDate => a.added_date.cmp(&b.added_date),
-            });
+            };
-            torrents.into_iter().map(|t| t.hash.clone()).collect::<Vec<String>>()
+            if dir == SortDirection::Descending { cmp.reverse() } else { cmp }
-        })
+        });
+        torrents.into_iter().map(|t| t.hash.clone()).collect::<Vec<String>>()
     };
 
     let handle_sort = move |col: SortColumn| {

frontend/src/store.rs

@@ -107,23 +107,42 @@ pub fn provide_torrent_store() {
     let store = TorrentStore { torrents, filter, search_query, global_stats, notifications, user };
     provide_context(store);
 
-    // SSE Connection
+    let notifications_for_effect = notifications;
-    Effect::new(move |_| {
+    let global_stats_for_effect = global_stats;
-        if user.get().is_none() { return; }
+    let torrents_for_effect = torrents;
+    let show_browser_notification = show_browser_notification.clone();
 
+    Effect::new(move |_| {
+        let user_val = user.get();
+        log::debug!("SSE Effect: user = {:?}", user_val);
+        if user_val.is_none() {
+            log::debug!("SSE Effect: user is None, skipping connection");
+            return;
+        }
+
+        let notifications = notifications_for_effect;
+        let global_stats = global_stats_for_effect;
+        let torrents = torrents_for_effect;
         let show_browser_notification = show_browser_notification.clone();
+
+        log::info!("SSE: Starting connection (user logged in)");
+
         leptos::task::spawn_local(async move {
             let mut backoff_ms: u32 = 1000;
             let mut was_connected = false;
             let mut disconnect_notified = false;
 
             loop {
+                log::debug!("SSE: Creating EventSource...");
                 let es_result = EventSource::new("/api/events");
                 match es_result {
                     Ok(mut es) => {
+                        log::debug!("SSE: EventSource created, subscribing to message channel...");
                         if let Ok(mut stream) = es.subscribe("message") {
+                            log::debug!("SSE: Subscribed to message channel");
                             let mut got_first_message = false;
                             while let Some(Ok((_, msg))) = stream.next().await {
+                                log::debug!("SSE: Received message: {:?}", msg.data());
                                 if !got_first_message {
                                     got_first_message = true;
                                     backoff_ms = 1000;
@@ -135,9 +154,11 @@ pub fn provide_torrent_store() {
                                 }
 
                                 if let Some(data_str) = msg.data().as_string() {
+                                    log::debug!("SSE: Parsing JSON: {}", data_str);
                                     if let Ok(event) = serde_json::from_str::<AppEvent>(&data_str) {
                                         match event {
                                             AppEvent::FullList { torrents: list, .. } => {
+                                                log::info!("SSE: Received FullList with {} torrents", list.len());
                                                 torrents.update(|map| {
                                                     let new_hashes: std::collections::HashSet<String> = list.iter().map(|t| t.hash.clone()).collect();
                                                     map.retain(|hash, _| new_hashes.contains(hash));
@@ -145,6 +166,7 @@ pub fn provide_torrent_store() {
                                                         map.insert(new_torrent.hash.clone(), new_torrent);
                                                     }
                                                 });
+                                                log::debug!("SSE: torrents map now has {} entries", torrents.with(|m| m.len()));
                                             }
                                             AppEvent::Update(update) => {
                                                 torrents.update(|map| {