Update app.py

app.py

@@ -204,4 +204,249 @@ async def websocket_handler(websocket, path):
                 chat_history[room_id].append(data)
                 if len(chat_history[room_id]) > 500:
                     chat_history[room_id] = chat_history[room_id][-500:]
-                save_message_to_history
+                save_message_to_history(room_id, data)
+                await broadcast_message(data, room_id)
+            except json.JSONDecodeError:
+                await websocket.send(json.dumps({"type": "error", "content": "Invalid JSON", "timestamp": datetime.now().isoformat(), "sender": "system", "room_id": room_id}))
+    except websockets.ConnectionClosed:
+        logger.info(f"Client {client_id} disconnected from room {room_id}")
+    finally:
+        if room_id in active_connections and client_id in active_connections[room_id]:
+            del active_connections[room_id][client_id]
+            sector_users[room_id].discard(client_id)
+            x, y = get_sector_coordinates(room_id)
+            leave_msg = {"type": "system", "content": f"User left (Sector {x},{y}) - {len(sector_users[room_id])} users", "timestamp": datetime.now().isoformat(), "sender": "system", "room_id": room_id}
+            await broadcast_message(leave_msg, room_id)
+            save_message_to_history(room_id, leave_msg)
+            if not active_connections[room_id]:
+                del active_connections[room_id]
+
+async def broadcast_message(message, room_id):
+    if room_id in active_connections:
+        disconnected = []
+        for client_id, ws in active_connections[room_id].items():
+            try:
+                await ws.send(json.dumps(message))
+            except websockets.ConnectionClosed:
+                disconnected.append(client_id)
+        for client_id in disconnected:
+            del active_connections[room_id][client_id]
+
+async def start_websocket_server(host='0.0.0.0', port=8765):
+    server = await websockets.serve(websocket_handler, host, port)
+    logger.info(f"WebSocket server started on ws://{host}:{port}")
+    return server
+
+main_event_loop = None
+message_queue = []
+
+def send_message(message, username, room_id):
+    if not message.strip():
+        return None
+    msg_data = {"type": "chat", "content": message, "username": username, "room_id": room_id}
+    message_queue.append(msg_data)
+    return f"{username}: {message}"
+
+def join_room(room_id, chat_history_output):
+    if not room_id.strip():
+        return "Please enter a valid room ID", chat_history_output
+    room_id = urllib.parse.quote(room_id.strip())
+    history = load_room_history(room_id)
+    formatted_history = [
+        f"[{datetime.fromisoformat(msg['timestamp']).strftime('%H:%M:%S')}] {msg.get('username', 'Anonymous')} [{'sender_node' in msg and msg['sender_node'] or 'unknown'}]: {msg['content']}"
+        if msg.get("type") == "chat" else f"System: {msg['content']}"
+        for msg in history
+    ]
+    return f"Joined room: {room_id}", "\n".join(formatted_history)
+
+def list_available_rooms():
+    history_files = list_all_history_files()
+    return "No chat rooms available yet. Join one to create it!" if not history_files else "### Available Chat Rooms\n\n" + "\n".join(
+        f"- **{room_id}**: Last activity {datetime.fromtimestamp(mod_time).strftime('%Y-%m-%d %H:%M:%S')}" for room_id, _, mod_time in history_files
+    )
+
+def create_gradio_interface():
+    with gr.Blocks(title=f"Chat Node: {NODE_NAME}") as interface:
+        # Custom CSS and JS
+        interface.css = """
+            #log-overlay {
+                position: fixed; top: 10px; right: 10px; width: 300px; height: 200px;
+                background: rgba(0, 0, 0, 0.8); color: white; padding: 10px; overflow-y: auto;
+                border-radius: 5px; z-index: 1000; display: none;
+            }
+            #threejs-container { width: 100%; height: 400px; }
+            .chat-container { margin-top: 20px; }
+        """
+        interface.js = """
+        async () => {
+            // Log Overlay
+            let logOverlay = document.createElement('div');
+            logOverlay.id = 'log-overlay';
+            document.body.appendChild(logOverlay);
+            let wsLogs = new WebSocket('ws://' + window.location.hostname + ':8765/logs');
+            wsLogs.onmessage = (event) => {
+                let data = JSON.parse(event.data);
+                if (data.type === 'log') {
+                    logOverlay.style.display = 'block';
+                    logOverlay.innerHTML += `<p>${data.timestamp} - ${data.content}</p>`;
+                    logOverlay.scrollTop = logOverlay.scrollHeight;
+                }
+            };
+            wsLogs.onerror = () => console.error('Log WebSocket error');
+            wsLogs.onclose = () => console.log('Log WebSocket closed');
+
+            // Three.js Sector Map
+            let container = document.getElementById('threejs-container');
+            if (!container) return;
+            const THREE = await import('https://cdn.jsdelivr.net/npm/[email protected]/build/three.module.js');
+            const scene = new THREE.Scene();
+            const camera = new THREE.PerspectiveCamera(75, container.clientWidth / container.clientHeight, 0.1, 1000);
+            const renderer = new THREE.WebGLRenderer();
+            renderer.setSize(container.clientWidth, container.clientHeight);
+            container.appendChild(renderer.domElement);
+
+            const gridSize = 10;
+            const geometry = new THREE.BoxGeometry(0.8, 0.8, 0.8);
+            const edges = new THREE.EdgesGeometry(geometry);
+            for (let x = 0; x < gridSize; x++) {
+                for (let y = 0; y < gridSize; y++) {
+                    const hasUsers = document.querySelector(`[data-room="${x},${y}"]`)?.dataset.users > 0;
+                    const material = new THREE.MeshBasicMaterial({ color: hasUsers ? 0x00ff00 : 0x333333 });
+                    const cube = new THREE.Mesh(geometry, material);
+                    cube.position.set(x - gridSize / 2, 0, y - gridSize / 2);
+                    scene.add(cube);
+                    if (hasUsers) {
+                        const line = new THREE.LineSegments(edges, new THREE.LineBasicMaterial({ color: 0xffffff }));
+                        line.position.set(x - gridSize / 2, 0, y - gridSize / 2);
+                        scene.add(line);
+                    }
+                }
+            }
+            camera.position.set(0, 10, 10);
+            camera.lookAt(0, 0, 0);
+
+            function animate() {
+                requestAnimationFrame(animate);
+                renderer.render(scene, camera);
+            }
+            animate();
+        }
+        """
+
+        gr.Markdown(f"# Chat Node: {NODE_NAME}")
+        gr.Markdown("Welcome! You've auto-joined a room with a fun username.")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                room_list = gr.Markdown(value=list_available_rooms())
+                refresh_button = gr.Button("🔄 Refresh Room List")
+            with gr.Column(scale=1):
+                clear_button = gr.Button("🧹 Clear All Chat History", variant="stop")
+        
+        gr.HTML('<div id="threejs-container"></div>')  # Three.js container
+        
+        with gr.Row():
+            room_id_input = gr.Textbox(label="Room ID", placeholder="Change room (e.g., '0,0')")
+            join_button = gr.Button("Join Room")
+        
+        chat_history_output = gr.Textbox(label="Chat History", lines=20, max_lines=20, elem_classes=["chat-container"])
+        
+        with gr.Row():
+            username_input = gr.Textbox(label="Username", value=random.choice(FUN_USERNAMES))
+            with gr.Column(scale=3):
+                message_input = gr.Textbox(label="Message", placeholder="Type here...", lines=3)
+            with gr.Column(scale=1):
+                send_button = gr.Button("Send")
+                map_button = gr.Button("🗺️ Show Map")
+        
+        current_room_display = gr.Textbox(label="Current Room", value="Auto-joining...")
+
+        # Event handlers
+        refresh_button.click(list_available_rooms, [], [room_list])
+        clear_button.click(lambda: (message_queue.append({"type": "command", "command": "clear_history", "username": "System"}), "🧹 Clearing..."), [], [room_list])
+        join_button.click(join_room, [room_id_input, chat_history_output], [current_room_display, chat_history_output])
+        
+        def send_and_clear(message, username, room_id):
+            if not room_id.startswith("Joined room:"):
+                return "", "Please join a room first"
+            actual_room_id = room_id.replace("Joined room: ", "").strip()
+            formatted_msg = send_message(message, username, actual_room_id)
+            return "", formatted_msg or ""
+        
+        send_button.click(send_and_clear, [message_input, username_input, current_room_display], [message_input, chat_history_output])
+        message_input.submit(send_and_clear, [message_input, username_input, current_room_display], [message_input, chat_history_output])
+        map_button.click(lambda room_id: generate_sector_map() if room_id.startswith("Joined room:") else "Join a room first", [current_room_display], [chat_history_output])
+        
+        # Auto-join on load
+        def auto_join():
+            random_room = f"{random.randint(0, GRID_WIDTH-1)},{random.randint(0, GRID_HEIGHT-1)}"
+            return join_room(random_room, "")
+        interface.load(auto_join, [], [current_room_display, chat_history_output])
+
+    return interface
+
+async def process_message_queue():
+    while True:
+        if message_queue:
+            msg_data = message_queue.pop(0)
+            await broadcast_message(msg_data, msg_data["room_id"])
+        await asyncio.sleep(0.1)
+
+async def process_logs():
+    while True:
+        global log_history
+        updated = False
+        for file in os.listdir(LOG_DIR):
+            if file.endswith(".jsonl"):
+                file_path = os.path.join(LOG_DIR, file)
+                current_mtime = os.path.getmtime(file_path)
+                if file_path not in file_modification_times or current_mtime > file_modification_times[file_path]:
+                    updated = True
+                    file_modification_times[file_path] = current_mtime
+        if updated:
+            log_history = []
+            for file in sorted([f for f in os.listdir(LOG_DIR) if f.endswith(".jsonl")], key=lambda x: os.path.getmtime(os.path.join(LOG_DIR, x))):
+                try:
+                    with open(os.path.join(LOG_DIR, file), 'r') as f:
+                        for line in f:
+                            if line.strip():
+                                log_history.append(json.loads(line))
+                except Exception as e:
+                    logger.error(f"Error loading logs from {file}: {e}")
+            log_msg = {"type": "log", "content": "\n".join(entry["message"] for entry in log_history[-10:]), "timestamp": datetime.now().isoformat(), "sender": "system", "room_id": "logs"}
+            await broadcast_message(log_msg, "logs")
+        await asyncio.sleep(1)
+
+class LogBroadcastHandler(logging.Handler):
+    def emit(self, record):
+        entry = {"timestamp": datetime.now().isoformat(), "level": record.levelname, "message": self.format(record), "name": record.name}
+        save_log_entry(entry)
+        log_history.append(entry)
+
+logger.addHandler(LogBroadcastHandler())
+
+async def main():
+    global NODE_NAME, main_event_loop
+    NODE_NAME, port = get_node_name()
+    main_event_loop = asyncio.get_running_loop()
+    await start_websocket_server()
+    asyncio.create_task(process_message_queue())
+    asyncio.create_task(process_logs())
+    interface = create_gradio_interface()
+    
+    from starlette.middleware.base import BaseHTTPMiddleware
+    class NodeNameMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request, call_next):
+            global NODE_NAME
+            if "node_name" in dict(request.query_params):
+                NODE_NAME = dict(request.query_params)["node_name"]
+                logger.info(f"Node name set to {NODE_NAME} from URL")
+            return await call_next(request)
+    
+    app = gr.routes.App.create_app(interface)
+    app.add_middleware(NodeNameMiddleware)
+    import uvicorn
+    await uvicorn.Server(uvicorn.Config(app, host="0.0.0.0", port=port)).serve()
+
+if __name__ == "__main__":
+    asyncio.run(main())