fix ci

Author: scrogson

…/starlang/src/application/application.rs crates/starlang/src/application/core.rscrates/starlang/src/application/application.rs renamed to crates/starlang/src/application/core.rs crates/starlang/src/application/application.rs renamed to crates/starlang/src/application/core.rs

@@ -44,11 +44,11 @@
 #![deny(warnings)]
 #![deny(missing_docs)]
 
-mod application;
+mod core;
 mod error;
 mod types;
 
-pub use application::{AppController, Application};
+pub use core::{AppController, Application};
 pub use error::{StartError, StopError};
 pub use types::{AppConfig, AppInfo, AppSpec, ConfigValue, StartResult};
 

crates/starlang/src/application/mod.rs

@@ -50,8 +50,8 @@
 #![deny(warnings)]
 #![deny(missing_docs)]
 
+mod core;
 mod error;
-mod supervisor;
 mod types;
 
 /// DynamicSupervisor for starting children on demand.
@@ -63,11 +63,11 @@ mod types;
 /// See [`dynamic_supervisor`] module for details.
 pub mod dynamic_supervisor;
 
-pub use error::{DeleteError, RestartError, StartError, TerminateError};
-pub use supervisor::{
+pub use core::{
     Supervisor, SupervisorInit, count_children, delete_child, start, start_link, terminate_child,
     which_children,
 };
+pub use error::{DeleteError, RestartError, StartError, TerminateError};
 pub use types::{
     ChildCounts, ChildInfo, ChildSpec, ChildType, RestartType, ShutdownType, StartChildError,
     Strategy, SupervisorFlags,

…es/starlang/src/supervisor/supervisor.rs crates/starlang/src/supervisor/core.rscrates/starlang/src/supervisor/supervisor.rs renamed to crates/starlang/src/supervisor/core.rs crates/starlang/src/supervisor/supervisor.rs renamed to crates/starlang/src/supervisor/core.rs

@@ -106,6 +106,11 @@ impl Session {
 
     /// Handle incoming channel messages (broadcasts from other users).
     async fn handle_channel_message(&mut self, data: &[u8]) {
+        tracing::debug!(
+            nick = ?self.nick,
+            data_len = data.len(),
+            "handle_channel_message called"
+        );
         // First, check if this is a presence message and apply it to the tracker
         if let Ok(presence_msg) = postcard::from_bytes::<starlang::presence::PresenceMessage>(data)
         {
@@ -139,77 +144,83 @@ impl Session {
         }
 
         // Now handle the message for client notification
-        if let Ok(reply) = postcard::from_bytes::<ChannelReply>(data) {
-            match reply {
-                ChannelReply::Push {
-                    topic,
-                    event: _,
-                    payload,
-                } => {
-                    // Decode the room event
-                    if let Ok(room_event) = postcard::from_bytes::<RoomOutEvent>(&payload) {
-                        let room_name = topic.strip_prefix("room:").unwrap_or(&topic);
-                        match room_event {
-                            RoomOutEvent::UserJoined { nick } => {
-                                self.send_event(ServerEvent::UserJoined {
-                                    room: room_name.to_string(),
-                                    nick,
-                                })
-                                .await;
-                            }
-                            RoomOutEvent::UserLeft { nick } => {
-                                self.send_event(ServerEvent::UserLeft {
-                                    room: room_name.to_string(),
-                                    nick,
-                                })
-                                .await;
-                            }
-                            RoomOutEvent::Message { from, text } => {
-                                self.send_event(ServerEvent::Message {
-                                    room: room_name.to_string(),
-                                    from,
-                                    text,
-                                })
-                                .await;
-                            }
-                            RoomOutEvent::PresenceState { users } => {
-                                self.send_event(ServerEvent::UserList {
-                                    room: room_name.to_string(),
-                                    users,
-                                })
-                                .await;
-                            }
-                            RoomOutEvent::PresenceSyncRequest { .. } => {
-                                // Handled by RoomChannel::handle_info above
-                            }
-                            RoomOutEvent::PresenceSyncResponse { nick } => {
-                                // An existing member announced themselves
-                                // Send this as a UserJoined so client adds them to list
-                                tracing::debug!(
-                                    room = %room_name,
-                                    nick = %nick,
-                                    "Received presence sync response, sending UserJoined to client"
-                                );
-                                self.send_event(ServerEvent::UserJoined {
-                                    room: room_name.to_string(),
-                                    nick,
-                                })
-                                .await;
-                            }
-                            RoomOutEvent::History { messages } => {
-                                // History is already sent directly by session.rs on join
-                                // This is just for consistency - forward if received via channel
-                                self.send_event(ServerEvent::History {
-                                    room: room_name.to_string(),
-                                    messages,
-                                })
-                                .await;
-                            }
-                        }
+        if let Ok(ChannelReply::Push {
+            topic,
+            event: _,
+            payload,
+        }) = postcard::from_bytes::<ChannelReply>(data)
+        {
+            // Decode the room event
+            if let Ok(room_event) = postcard::from_bytes::<RoomOutEvent>(&payload) {
+                let room_name = topic.strip_prefix("room:").unwrap_or(&topic);
+                match room_event {
+                    RoomOutEvent::UserJoined { nick } => {
+                        tracing::debug!(
+                            room = %room_name,
+                            joined_nick = %nick,
+                            my_nick = ?self.nick,
+                            "Received UserJoined, sending to client"
+                        );
+                        self.send_event(ServerEvent::UserJoined {
+                            room: room_name.to_string(),
+                            nick,
+                        })
+                        .await;
+                    }
+                    RoomOutEvent::UserLeft { nick } => {
+                        self.send_event(ServerEvent::UserLeft {
+                            room: room_name.to_string(),
+                            nick,
+                        })
+                        .await;
+                    }
+                    RoomOutEvent::Message { from, text } => {
+                        self.send_event(ServerEvent::Message {
+                            room: room_name.to_string(),
+                            from,
+                            text,
+                        })
+                        .await;
+                    }
+                    RoomOutEvent::PresenceState { users } => {
+                        tracing::debug!(
+                            room = %room_name,
+                            users = ?users,
+                            nick = ?self.nick,
+                            "Received PresenceState, sending UserList to client"
+                        );
+                        self.send_event(ServerEvent::UserList {
+                            room: room_name.to_string(),
+                            users,
+                        })
+                        .await;
+                    }
+                    RoomOutEvent::PresenceSyncRequest { .. } => {
+                        // Handled by RoomChannel::handle_info above
+                    }
+                    RoomOutEvent::PresenceSyncResponse { nick } => {
+                        // An existing member announced themselves
+                        // Send this as a UserJoined so client adds them to list
+                        tracing::debug!(
+                            room = %room_name,
+                            nick = %nick,
+                            "Received presence sync response, sending UserJoined to client"
+                        );
+                        self.send_event(ServerEvent::UserJoined {
+                            room: room_name.to_string(),
+                            nick,
+                        })
+                        .await;
+                    }
+                    RoomOutEvent::History { messages } => {
+                        // History is already sent directly by session.rs on join
+                        // This is just for consistency - forward if received via channel
+                        self.send_event(ServerEvent::History {
+                            room: room_name.to_string(),
+                            messages,
+                        })
+                        .await;
                     }
-                }
-                _ => {
-                    // Other replies are handled inline
                 }
             }
         }

crates/starlang/src/supervisor/mod.rs

@@ -9,7 +9,14 @@ use tokio::process::{Child, Command};
 use tokio::time::timeout;
 
 /// Helper to start a chat server process.
-async fn start_server(name: &str, port: u16, dist_port: u16, connect: Option<&str>) -> Child {
+async fn start_server(
+    name: &str,
+    port: u16,
+    dist_port: u16,
+    ws_port: u16,
+    http_port: u16,
+    connect: Option<&str>,
+) -> Child {
     // Use the debug binary (built by cargo test)
     // CARGO_MANIFEST_DIR points to examples/chat, so we go up two levels to workspace root
     let manifest_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
@@ -22,16 +29,23 @@ async fn start_server(name: &str, port: u16, dist_port: u16, connect: Option<&st
         .arg("--port")
         .arg(port.to_string())
         .arg("--dist-port")
-        .arg(dist_port.to_string());
+        .arg(dist_port.to_string())
+        .arg("--ws-port")
+        .arg(ws_port.to_string())
+        .arg("--http-port")
+        .arg(http_port.to_string());
 
     if let Some(peer) = connect {
         cmd.arg("--connect").arg(peer);
     }
 
-    cmd.env("RUST_LOG", "info,starlang::distribution=debug")
-        .kill_on_drop(true)
-        .spawn()
-        .unwrap_or_else(|e| panic!("Failed to start server from {:?}: {}", binary, e))
+    cmd.env(
+        "RUST_LOG",
+        "info,starlang::distribution=debug,chat_server::session=debug,chat_server::channel=debug",
+    )
+    .kill_on_drop(true)
+    .spawn()
+    .unwrap_or_else(|e| panic!("Failed to start server from {:?}: {}", binary, e))
 }
 
 /// Helper to connect a client and return the stream.
@@ -153,7 +167,7 @@ struct RoomInfo {
 #[tokio::test]
 async fn test_single_node_chat() {
     // Start a single server
-    let mut server = start_server("node1", 19999, 19000, None).await;
+    let mut server = start_server("node1", 19999, 19000, 14000, 18080, None).await;
 
     // Give server time to start
     tokio::time::sleep(Duration::from_secs(1)).await;
@@ -253,11 +267,12 @@ async fn test_single_node_chat() {
 #[tokio::test]
 async fn test_cross_node_global_registry() {
     // Start node1
-    let mut node1 = start_server("node1", 29999, 29000, None).await;
+    let mut node1 = start_server("node1", 29999, 29000, 24000, 28080, None).await;
     tokio::time::sleep(Duration::from_secs(1)).await;
 
     // Start node2 and connect to node1
-    let mut node2 = start_server("node2", 29998, 29001, Some("127.0.0.1:29000")).await;
+    let mut node2 =
+        start_server("node2", 29998, 29001, 24001, 28081, Some("127.0.0.1:29000")).await;
     tokio::time::sleep(Duration::from_secs(2)).await; // Extra time for distribution handshake
 
     // Connect alice to node1
@@ -284,9 +299,15 @@ async fn test_cross_node_global_registry() {
         resp
     );
 
-    // Give time for global registry to sync
+    // Give time for global registry to sync and drain any pending messages (like UserList from PushPresenceState)
     tokio::time::sleep(Duration::from_millis(500)).await;
 
+    // Drain any pending messages from Alice (like UserList sent after her own join)
+    while let Ok(msg) = timeout(Duration::from_millis(100), read_message(&mut alice)).await {
+        let event = decode_event(&msg);
+        tracing::debug!("Drained pending message from Alice: {:?}", event);
+    }
+
     // Connect bob to node2
     let mut bob = connect_client(29998).await;
     let _ = read_message(&mut bob).await; // welcome
@@ -356,11 +377,12 @@ async fn test_cross_node_global_registry() {
 #[tokio::test]
 async fn test_room_list_across_nodes() {
     // Start node1
-    let mut node1 = start_server("node1", 39999, 39000, None).await;
+    let mut node1 = start_server("node1", 39999, 39000, 34000, 38080, None).await;
     tokio::time::sleep(Duration::from_secs(1)).await;
 
     // Start node2 connected to node1
-    let mut node2 = start_server("node2", 39998, 39001, Some("127.0.0.1:39000")).await;
+    let mut node2 =
+        start_server("node2", 39998, 39001, 34001, 38081, Some("127.0.0.1:39000")).await;
     tokio::time::sleep(Duration::from_secs(2)).await;
 
     // Connect alice to node1 and create a room