Enhance development workflow and deployment practices for Archipelago

- Updated the Development-Workflow documentation to clarify deployment strategy, emphasizing direct deployment to the live system for testing.
- Added detailed instructions for the deployment command, including syncing code, building frontend and backend, and restarting services.
- Improved SSH key management section to assist with authentication issues.
- Expanded the testing workflow to include steps for checking logs and syncing changes back to the ISO build.
- Updated the ISO build integration section to ensure system-level changes are captured for future builds.
- Refactored various sections for clarity and completeness, including deployment paths and system configuration files.

core/archipelago/src/api/handler.rs

@@ -6,6 +6,7 @@ use futures_util::{SinkExt, StreamExt};
 use hyper::{Method, Request, Response, StatusCode};
 use hyper_ws_listener::WsStream;
 use std::sync::Arc;
+use tokio::sync::broadcast;
 use tokio_tungstenite::tungstenite::Message;
 use tracing::{debug, info};
 
@@ -94,11 +95,14 @@ impl ApiHandler {
                     debug!("Sent initial data dump at revision {}", initial_msg.rev);
                 }
                 
+                // Subscribe to state updates
+                let mut state_rx = state_manager.subscribe();
+                
                 // Send periodic pings to keep connection alive
                 let ping_interval = tokio::time::interval(tokio::time::Duration::from_secs(30));
                 tokio::pin!(ping_interval);
                 
-                // Keep connection open; UI may send/receive JSON patches. For now just accept and ignore.
+                // Keep connection open and forward state updates to client
                 loop {
                     tokio::select! {
                         _ = ping_interval.tick() => {
@@ -107,6 +111,28 @@ impl ApiHandler {
                                 break;
                             }
                         }
+                        // Forward state updates from broadcast channel to WebSocket
+                        update = state_rx.recv() => {
+                            match update {
+                                Ok(msg) => {
+                                    if let Ok(json_msg) = serde_json::to_string(&msg) {
+                                        if let Err(e) = tx.send(Message::Text(json_msg)).await {
+                                            debug!("Failed to send state update: {}", e);
+                                            break;
+                                        }
+                                        debug!("Sent state update at revision {}", msg.rev);
+                                    }
+                                }
+                                Err(broadcast::error::RecvError::Lagged(skipped)) => {
+                                    debug!("Client lagged behind, skipped {} messages", skipped);
+                                    // Continue receiving - the client will get the next update
+                                }
+                                Err(broadcast::error::RecvError::Closed) => {
+                                    debug!("Broadcast channel closed");
+                                    break;
+                                }
+                            }
+                        }
                         msg = rx.next() => {
                             match msg {
                                 Some(Ok(Message::Close(_))) => break,