jettypod 4.4.118 → 4.4.121

package/crates/jettypod-core/src/ws.rs

@@ -0,0 +1,767 @@
+//! WebSocket server for live dashboard updates.
+//!
+//! Broadcasts `db_change` and `test_change` events when the work database
+//! or test results are modified.  Uses native file watching (kqueue/FSEvents
+//! on macOS, inotify on Linux) for instant change detection, with mtime
+//! polling as a fallback.
+//!
+//! ## Usage
+//!
+//! ```rust,no_run
+//! use jettypod_core::ws::{WsServer, WsConfig};
+//! use std::path::PathBuf;
+//! use tokio::sync::broadcast;
+//!
+//! #[tokio::main]
+//! async fn main() {
+//!     let config = WsConfig {
+//!         port: 47808,
+//!         project_root: PathBuf::from("/path/to/project"),
+//!     };
+//!     let (tx, _) = broadcast::channel::<String>(64);
+//!     let server = WsServer::new(config);
+//!     server.run(tx).await.unwrap();
+//! }
+//! ```
+
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant, SystemTime};
+
+use futures_util::{SinkExt, StreamExt};
+use serde::Serialize;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::{broadcast, RwLock};
+use tokio_tungstenite::tungstenite::Message as WsMessage;
+
+use notify::Watcher;
+
+use crate::error::{CoreError, Result};
+
+/// Default WebSocket port (matches Node.js `WS_PORT`).
+pub const DEFAULT_PORT: u16 = 47808;
+
+/// Debounce window for native file watch events (milliseconds).
+const DEBOUNCE_MS: u64 = 100;
+
+/// Polling interval for fallback mtime checks (milliseconds).
+const POLL_MS: u64 = 500;
+
+// ---------------------------------------------------------------------------
+// Message types
+// ---------------------------------------------------------------------------
+
+/// A broadcast message sent to all connected clients.
+#[derive(Debug, Clone, Serialize)]
+pub struct BroadcastMessage {
+    #[serde(rename = "type")]
+    pub msg_type: String,
+    pub timestamp: u64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub table: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rowid: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub action: Option<String>,
+}
+
+impl BroadcastMessage {
+    pub fn db_change() -> Self {
+        Self {
+            msg_type: "db_change".into(),
+            timestamp: now_millis(),
+            table: None,
+            rowid: None,
+            action: None,
+        }
+    }
+
+    pub fn db_delta(action: &str, table: &str, rowid: i64) -> Self {
+        Self {
+            msg_type: "db_delta".into(),
+            timestamp: now_millis(),
+            table: Some(table.to_string()),
+            rowid: Some(rowid),
+            action: Some(action.to_string()),
+        }
+    }
+
+    pub fn test_change() -> Self {
+        Self {
+            msg_type: "test_change".into(),
+            timestamp: now_millis(),
+            table: None,
+            rowid: None,
+            action: None,
+        }
+    }
+
+    pub fn connected() -> Self {
+        Self {
+            msg_type: "connected".into(),
+            timestamp: now_millis(),
+            table: None,
+            rowid: None,
+            action: None,
+        }
+    }
+
+    pub fn to_json(&self) -> String {
+        serde_json::to_string(self).unwrap_or_default()
+    }
+}
+
+fn now_millis() -> u64 {
+    SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as u64
+}
+
+// ---------------------------------------------------------------------------
+// Native file watcher
+// ---------------------------------------------------------------------------
+
+/// Set up native file watching for database and test result changes.
+///
+/// Watches the parent directories of the target files and filters events
+/// by filename. Spawns a dedicated thread for the blocking event loop.
+fn setup_file_watcher(
+    db_path: &Path,
+    test_path: &Path,
+    tx: &broadcast::Sender<String>,
+) -> std::result::Result<(), Box<dyn std::error::Error>> {
+    let (notify_tx, notify_rx) = std::sync::mpsc::channel();
+    let mut watcher = notify::recommended_watcher(notify_tx)?;
+
+    let db_dir = db_path.parent().ok_or("db_path has no parent directory")?;
+    watcher.watch(db_dir, notify::RecursiveMode::NonRecursive)?;
+
+    let test_dir = test_path.parent().ok_or("test_path has no parent directory")?;
+    if test_dir != db_dir {
+        watcher.watch(test_dir, notify::RecursiveMode::NonRecursive)?;
+    }
+
+    let db_name = db_path
+        .file_name()
+        .ok_or("db_path has no filename")?
+        .to_owned();
+    let wal_path = db_path.with_extension("db-wal");
+    let wal_name = wal_path
+        .file_name()
+        .ok_or("wal path has no filename")?
+        .to_owned();
+    let test_name = test_path
+        .file_name()
+        .ok_or("test_path has no filename")?
+        .to_owned();
+    let tx = tx.clone();
+
+    std::thread::Builder::new()
+        .name("jettypod-fswatcher".into())
+        .spawn(move || {
+            let _watcher = watcher; // Must stay alive for watching to continue
+            let debounce = Duration::from_millis(DEBOUNCE_MS);
+            let mut last_db = Instant::now() - Duration::from_secs(60);
+            let mut last_test = Instant::now() - Duration::from_secs(60);
+
+            for result in notify_rx {
+                match result {
+                    Ok(event) => {
+                        let now = Instant::now();
+                        for path in &event.paths {
+                            let fname = match path.file_name() {
+                                Some(f) => f,
+                                None => continue,
+                            };
+                            if (fname == db_name || fname == wal_name)
+                                && now.duration_since(last_db) > debounce
+                            {
+                                last_db = now;
+                                let _ = tx.send(BroadcastMessage::db_change().to_json());
+                            } else if fname == test_name
+                                && now.duration_since(last_test) > debounce
+                            {
+                                last_test = now;
+                                let _ = tx.send(BroadcastMessage::test_change().to_json());
+                            }
+                        }
+                    }
+                    Err(e) => log::debug!("File watch error: {e}"),
+                }
+            }
+        })
+        .map_err(|e| -> Box<dyn std::error::Error> { Box::new(e) })?;
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Mtime tracking (polling fallback)
+// ---------------------------------------------------------------------------
+
+/// Tracks file modification times for change detection.
+#[derive(Debug, Default)]
+struct MtimeTracker {
+    db: Option<u64>,
+    wal: Option<u64>,
+}
+
+/// Get the mtime of a file in milliseconds, or `None` if it doesn't exist.
+fn file_mtime_ms(path: &Path) -> Option<u64> {
+    std::fs::metadata(path)
+        .ok()
+        .and_then(|m| m.modified().ok())
+        .and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
+        .map(|d| d.as_millis() as u64)
+}
+
+/// Check if the database files have changed since the last poll.
+fn check_db_changed(db_path: &Path, last: &mut MtimeTracker) -> bool {
+    let current_db = file_mtime_ms(db_path);
+    let wal_path = db_path.with_extension("db-wal");
+    let current_wal = file_mtime_ms(&wal_path);
+
+    let changed = current_db != last.db || current_wal != last.wal;
+    last.db = current_db;
+    last.wal = current_wal;
+    changed
+}
+
+/// Check if a single file has changed since the last poll.
+fn check_file_changed(path: &Path, last: &mut Option<u64>) -> bool {
+    let current = file_mtime_ms(path);
+    let changed = current != *last;
+    *last = current;
+    changed
+}
+
+// ---------------------------------------------------------------------------
+// Server config
+// ---------------------------------------------------------------------------
+
+/// Configuration for the WebSocket server.
+#[derive(Debug, Clone)]
+pub struct WsConfig {
+    /// Port to listen on (default: 47808).
+    pub port: u16,
+    /// Project root directory containing `.jettypod/`.
+    pub project_root: PathBuf,
+}
+
+impl Default for WsConfig {
+    fn default() -> Self {
+        Self {
+            port: DEFAULT_PORT,
+            project_root: PathBuf::from("."),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+
+/// State shared between the accept loop and watcher tasks.
+struct ServerState {
+    /// Broadcast channel for sending messages to all clients.
+    broadcast_tx: broadcast::Sender<String>,
+    /// Count of connected clients (for stats).
+    client_count: RwLock<usize>,
+}
+
+/// The WebSocket server.
+pub struct WsServer {
+    config: WsConfig,
+}
+
+impl WsServer {
+    pub fn new(config: WsConfig) -> Self {
+        Self { config }
+    }
+
+    /// Run the server with an externally-created broadcast sender.
+    ///
+    /// The sender is shared with callers (e.g., SQLite update_hook) so they
+    /// can inject messages directly without going through file watching.
+    ///
+    /// Spawns:
+    /// 1. TCP accept loop (handles new WS connections)
+    /// 2. File watcher thread (broadcasts db_change/test_change via native OS events)
+    ///    Falls back to mtime polling if native watching is unavailable.
+    pub async fn run(&self, broadcast_tx: broadcast::Sender<String>) -> Result<()> {
+        let addr = format!("127.0.0.1:{}", self.config.port);
+        let listener = TcpListener::bind(&addr)
+            .await
+            .map_err(|e| CoreError::Other(format!("ws bind failed on {addr}: {e}")))?;
+
+        let state = Arc::new(ServerState {
+            broadcast_tx: broadcast_tx.clone(),
+            client_count: RwLock::new(0),
+        });
+
+        let db_path = self
+            .config
+            .project_root
+            .join(".jettypod")
+            .join("work.db");
+        let test_results_path = self.config.project_root.join("cucumber-results.json");
+
+        // Try native file watching, fall back to mtime polling if unavailable.
+        match setup_file_watcher(&db_path, &test_results_path, &broadcast_tx) {
+            Ok(()) => log::info!("Using native file watching for change detection"),
+            Err(e) => {
+                log::warn!("Native file watch unavailable ({e}), using mtime polling");
+                let tx_db = broadcast_tx.clone();
+                let db_path_clone = db_path.clone();
+                tokio::spawn(async move {
+                    poll_db_changes(&db_path_clone, tx_db).await;
+                });
+                let tx_test = broadcast_tx.clone();
+                let test_path_clone = test_results_path.clone();
+                tokio::spawn(async move {
+                    poll_test_changes(&test_path_clone, tx_test).await;
+                });
+            }
+        }
+
+        // Accept loop
+        loop {
+            let (stream, _addr) = listener
+                .accept()
+                .await
+                .map_err(|e| CoreError::Other(format!("ws accept error: {e}")))?;
+
+            let state = state.clone();
+            tokio::spawn(async move {
+                if let Err(e) = handle_connection(stream, state).await {
+                    log::debug!("ws connection error: {e}");
+                }
+            });
+        }
+    }
+}
+
+/// Start a WS server on a background thread with its own tokio runtime.
+///
+/// Returns the broadcast sender so callers (e.g., SQLite update_hook) can
+/// inject messages directly into the WebSocket broadcast channel.
+///
+/// This works regardless of whether a tokio runtime already exists on the
+/// calling thread (CLI) or not (Tauri IPC handlers).
+pub fn spawn_server(config: WsConfig) -> (std::thread::JoinHandle<()>, broadcast::Sender<String>) {
+    let (broadcast_tx, _) = broadcast::channel::<String>(64);
+    let tx_for_server = broadcast_tx.clone();
+
+    let handle = std::thread::Builder::new()
+        .name("jettypod-ws".into())
+        .spawn(move || {
+            let rt = tokio::runtime::Runtime::new()
+                .expect("Failed to create tokio runtime for WS server");
+            rt.block_on(async {
+                let server = WsServer::new(config);
+                if let Err(e) = server.run(tx_for_server).await {
+                    log::error!("WebSocket server error: {e}");
+                }
+            });
+        })
+        .expect("Failed to spawn WS server thread");
+
+    (handle, broadcast_tx)
+}
+
+// ---------------------------------------------------------------------------
+// Connection handler
+// ---------------------------------------------------------------------------
+
+async fn handle_connection(
+    stream: TcpStream,
+    state: Arc<ServerState>,
+) -> std::result::Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let ws_stream = tokio_tungstenite::accept_async(stream).await?;
+    let (mut ws_sender, mut ws_receiver) = ws_stream.split();
+
+    // Increment client count
+    {
+        let mut count = state.client_count.write().await;
+        *count += 1;
+    }
+
+    // Send connected message
+    let connected = BroadcastMessage::connected().to_json();
+    ws_sender.send(WsMessage::Text(connected.into())).await?;
+
+    // Subscribe to broadcast channel
+    let mut rx = state.broadcast_tx.subscribe();
+
+    // Two tasks: forward broadcasts to client, and drain incoming messages
+    let send_task = tokio::spawn(async move {
+        while let Ok(msg) = rx.recv().await {
+            if ws_sender.send(WsMessage::Text(msg.into())).await.is_err() {
+                break;
+            }
+        }
+    });
+
+    let recv_task = tokio::spawn(async move {
+        // We don't process incoming messages, just drain them
+        while let Some(Ok(_msg)) = ws_receiver.next().await {}
+    });
+
+    // Wait for either to finish (client disconnect)
+    tokio::select! {
+        _ = send_task => {},
+        _ = recv_task => {},
+    }
+
+    // Decrement client count
+    {
+        let mut count = state.client_count.write().await;
+        *count = count.saturating_sub(1);
+    }
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Polling fallback
+// ---------------------------------------------------------------------------
+
+async fn poll_db_changes(db_path: &Path, tx: broadcast::Sender<String>) {
+    let mut tracker = MtimeTracker::default();
+    let interval = Duration::from_millis(POLL_MS);
+
+    // Initialize tracker with current state (skip first "change")
+    let _ = check_db_changed(db_path, &mut tracker);
+
+    loop {
+        tokio::time::sleep(interval).await;
+
+        if check_db_changed(db_path, &mut tracker) {
+            let msg = BroadcastMessage::db_change().to_json();
+            if tx.send(msg).is_err() {
+                log::trace!("No active WebSocket receivers for db change");
+            }
+        }
+    }
+}
+
+async fn poll_test_changes(test_path: &Path, tx: broadcast::Sender<String>) {
+    let mut last_mtime: Option<u64> = None;
+    let interval = Duration::from_millis(POLL_MS);
+
+    // Initialize
+    let _ = check_file_changed(test_path, &mut last_mtime);
+
+    loop {
+        tokio::time::sleep(interval).await;
+
+        if check_file_changed(test_path, &mut last_mtime) {
+            let msg = BroadcastMessage::test_change().to_json();
+            if tx.send(msg).is_err() {
+                log::trace!("No active WebSocket receivers for test change");
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn broadcast_message_serialization() {
+        let msg = BroadcastMessage::db_change();
+        let json = msg.to_json();
+        assert!(json.contains("\"type\":\"db_change\""));
+        assert!(json.contains("\"timestamp\""));
+    }
+
+    #[test]
+    fn connected_message() {
+        let msg = BroadcastMessage::connected();
+        let json = msg.to_json();
+        assert!(json.contains("\"type\":\"connected\""));
+    }
+
+    #[test]
+    fn test_change_message() {
+        let msg = BroadcastMessage::test_change();
+        let json = msg.to_json();
+        assert!(json.contains("\"type\":\"test_change\""));
+    }
+
+    #[test]
+    fn mtime_tracker_detects_changes() {
+        let dir = TempDir::new().unwrap();
+        let db_path = dir.path().join("work.db");
+        std::fs::write(&db_path, "initial").unwrap();
+
+        let mut tracker = MtimeTracker::default();
+
+        // First call initializes — always "changed"
+        assert!(check_db_changed(&db_path, &mut tracker));
+
+        // No change
+        assert!(!check_db_changed(&db_path, &mut tracker));
+
+        // Modify file
+        std::thread::sleep(Duration::from_millis(50));
+        std::fs::write(&db_path, "modified").unwrap();
+        assert!(check_db_changed(&db_path, &mut tracker));
+    }
+
+    #[test]
+    fn file_changed_tracker() {
+        let dir = TempDir::new().unwrap();
+        let path = dir.path().join("results.json");
+
+        let mut last: Option<u64> = None;
+
+        // File doesn't exist — no change from None to None
+        assert!(!check_file_changed(&path, &mut last));
+
+        // Create file
+        std::fs::write(&path, "{}").unwrap();
+        assert!(check_file_changed(&path, &mut last));
+
+        // No change
+        assert!(!check_file_changed(&path, &mut last));
+    }
+
+    #[test]
+    fn now_millis_returns_positive() {
+        assert!(now_millis() > 0);
+    }
+
+    #[test]
+    fn db_delta_message_serialization() {
+        let msg = BroadcastMessage::db_delta("update", "work_items", 42);
+        let json = msg.to_json();
+        assert!(json.contains("\"type\":\"db_delta\""));
+        assert!(json.contains("\"table\":\"work_items\""));
+        assert!(json.contains("\"rowid\":42"));
+        assert!(json.contains("\"action\":\"update\""));
+        assert!(json.contains("\"timestamp\""));
+    }
+
+    #[test]
+    fn db_delta_insert_action() {
+        let msg = BroadcastMessage::db_delta("insert", "work_items", 1);
+        let json = msg.to_json();
+        assert!(json.contains("\"action\":\"insert\""));
+        assert!(json.contains("\"rowid\":1"));
+    }
+
+    #[test]
+    fn db_delta_delete_action() {
+        let msg = BroadcastMessage::db_delta("delete", "work_items", 99);
+        let json = msg.to_json();
+        assert!(json.contains("\"action\":\"delete\""));
+        assert!(json.contains("\"rowid\":99"));
+    }
+
+    #[test]
+    fn db_change_omits_delta_fields() {
+        let msg = BroadcastMessage::db_change();
+        let json = msg.to_json();
+        assert!(!json.contains("\"table\""));
+        assert!(!json.contains("\"rowid\""));
+        assert!(!json.contains("\"action\""));
+    }
+
+    #[test]
+    fn connected_message_omits_delta_fields() {
+        let msg = BroadcastMessage::connected();
+        let json = msg.to_json();
+        assert!(!json.contains("\"table\""));
+        assert!(!json.contains("\"rowid\""));
+        assert!(!json.contains("\"action\""));
+    }
+
+    #[test]
+    fn test_change_omits_delta_fields() {
+        let msg = BroadcastMessage::test_change();
+        let json = msg.to_json();
+        assert!(!json.contains("\"table\""));
+        assert!(!json.contains("\"rowid\""));
+        assert!(!json.contains("\"action\""));
+    }
+
+    #[test]
+    fn db_delta_roundtrips_through_json() {
+        let msg = BroadcastMessage::db_delta("update", "work_items", 7);
+        let json = msg.to_json();
+        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed["type"], "db_delta");
+        assert_eq!(parsed["table"], "work_items");
+        assert_eq!(parsed["rowid"], 7);
+        assert_eq!(parsed["action"], "update");
+        assert!(parsed["timestamp"].as_u64().unwrap() > 0);
+    }
+
+    #[tokio::test]
+    async fn server_binds_and_accepts() {
+        let addr = "127.0.0.1:0";
+        let listener = TcpListener::bind(addr).await.unwrap();
+        let local_addr = listener.local_addr().unwrap();
+        assert!(local_addr.port() > 0);
+    }
+
+    #[test]
+    fn file_watcher_initializes() {
+        let dir = TempDir::new().unwrap();
+        let db_path = dir.path().join("work.db");
+        let test_path = dir.path().join("cucumber-results.json");
+        std::fs::write(&db_path, "test").unwrap();
+
+        let (tx, _rx) = broadcast::channel::<String>(16);
+        let result = setup_file_watcher(&db_path, &test_path, &tx);
+        assert!(result.is_ok(), "File watcher should initialize: {result:?}");
+    }
+
+    #[test]
+    fn file_watcher_detects_db_change() {
+        let dir = TempDir::new().unwrap();
+        let db_path = dir.path().join("work.db");
+        let test_path = dir.path().join("cucumber-results.json");
+        std::fs::write(&db_path, "initial").unwrap();
+
+        let (tx, mut rx) = broadcast::channel::<String>(16);
+        setup_file_watcher(&db_path, &test_path, &tx).unwrap();
+
+        // Give watcher time to start
+        std::thread::sleep(Duration::from_millis(200));
+
+        // Modify the db file
+        std::fs::write(&db_path, "modified").unwrap();
+
+        // Wait for event with timeout
+        let deadline = Instant::now() + Duration::from_secs(2);
+        loop {
+            match rx.try_recv() {
+                Ok(msg) => {
+                    let parsed: serde_json::Value = serde_json::from_str(&msg).unwrap();
+                    assert_eq!(parsed["type"], "db_change");
+                    return;
+                }
+                Err(broadcast::error::TryRecvError::Empty) => {
+                    if Instant::now() > deadline {
+                        panic!("Timed out waiting for db_change event");
+                    }
+                    std::thread::sleep(Duration::from_millis(50));
+                }
+                Err(e) => panic!("Unexpected recv error: {e}"),
+            }
+        }
+    }
+
+    #[test]
+    fn file_watcher_detects_test_change() {
+        let dir = TempDir::new().unwrap();
+        let db_path = dir.path().join("work.db");
+        let test_path = dir.path().join("cucumber-results.json");
+        std::fs::write(&db_path, "db").unwrap();
+
+        let (tx, mut rx) = broadcast::channel::<String>(16);
+        setup_file_watcher(&db_path, &test_path, &tx).unwrap();
+
+        std::thread::sleep(Duration::from_millis(200));
+
+        // Create the test results file
+        std::fs::write(&test_path, "{\"results\":[]}").unwrap();
+
+        let deadline = Instant::now() + Duration::from_secs(2);
+        loop {
+            match rx.try_recv() {
+                Ok(msg) => {
+                    let parsed: serde_json::Value = serde_json::from_str(&msg).unwrap();
+                    assert_eq!(parsed["type"], "test_change");
+                    return;
+                }
+                Err(broadcast::error::TryRecvError::Empty) => {
+                    if Instant::now() > deadline {
+                        panic!("Timed out waiting for test_change event");
+                    }
+                    std::thread::sleep(Duration::from_millis(50));
+                }
+                Err(e) => panic!("Unexpected recv error: {e}"),
+            }
+        }
+    }
+
+    #[test]
+    fn file_watcher_debounces_rapid_changes() {
+        let dir = TempDir::new().unwrap();
+        let db_path = dir.path().join("work.db");
+        let test_path = dir.path().join("cucumber-results.json");
+        std::fs::write(&db_path, "initial").unwrap();
+
+        let (tx, mut rx) = broadcast::channel::<String>(64);
+        setup_file_watcher(&db_path, &test_path, &tx).unwrap();
+
+        std::thread::sleep(Duration::from_millis(200));
+
+        // Rapid-fire writes (simulating SQLite WAL checkpoint)
+        for i in 0..10 {
+            std::fs::write(&db_path, format!("write-{i}")).unwrap();
+        }
+
+        // Wait for events to settle
+        std::thread::sleep(Duration::from_millis(500));
+
+        // Count received events — should be much less than 10 due to debouncing
+        let mut count = 0;
+        while rx.try_recv().is_ok() {
+            count += 1;
+        }
+
+        assert!(
+            count < 10,
+            "Expected debouncing to reduce events to fewer than 10, got {count}"
+        );
+        assert!(count >= 1, "Expected at least 1 event, got {count}");
+    }
+
+    #[test]
+    fn file_watcher_separates_db_and_test_events() {
+        let dir = TempDir::new().unwrap();
+        let db_path = dir.path().join("work.db");
+        let test_path = dir.path().join("cucumber-results.json");
+        std::fs::write(&db_path, "db-initial").unwrap();
+        std::fs::write(&test_path, "test-initial").unwrap();
+
+        let (tx, mut rx) = broadcast::channel::<String>(64);
+        setup_file_watcher(&db_path, &test_path, &tx).unwrap();
+
+        std::thread::sleep(Duration::from_millis(200));
+
+        // Modify db file
+        std::fs::write(&db_path, "db-modified").unwrap();
+        std::thread::sleep(Duration::from_millis(200));
+
+        // Modify test file
+        std::fs::write(&test_path, "test-modified").unwrap();
+        std::thread::sleep(Duration::from_millis(200));
+
+        // Collect all events
+        let mut db_events = 0;
+        let mut test_events = 0;
+        while let Ok(msg) = rx.try_recv() {
+            let parsed: serde_json::Value = serde_json::from_str(&msg).unwrap();
+            match parsed["type"].as_str().unwrap() {
+                "db_change" => db_events += 1,
+                "test_change" => test_events += 1,
+                other => panic!("Unexpected event type: {other}"),
+            }
+        }
+
+        assert!(db_events >= 1, "Expected at least 1 db_change, got {db_events}");
+        assert!(test_events >= 1, "Expected at least 1 test_change, got {test_events}");
+    }
+}