Update app.py

app.py

@@ -1,545 +1,791 @@
-import streamlit as st
+import gradio as gr
 import asyncio
 import websockets
+import json
 import uuid
 import argparse
+import urllib.parse
 from datetime import datetime
+import logging
+import sys
 import os
-import random
 import time
-import hashlib
-from PIL import Image
-import glob
-from urllib.parse import quote
-import base64
-import io
-import streamlit.components.v1 as components
-import edge_tts
-from audio_recorder_streamlit import audio_recorder
-import nest_asyncio
+from pathlib import Path
 
-# Apply patch to allow nested asyncio.run() calls
-nest_asyncio.apply()
-
-# Initial App Configuration (static)
-icons = '🤖🧠🔬📝'
-START_ROOM = "Sector 🌌"
-
-# Set page config once at the top
-st.set_page_config(
-    page_title="🤖🧠MMO Chat Brain📝🔬",  # Initial static title
-    page_icon=icons,
-    layout="wide",
-    initial_sidebar_state="auto"
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
 )
+logger = logging.getLogger("chat-node")
 
-# Fun usernames with emojis and their paired voices
-FUN_USERNAMES = {
-    "CosmicJester 🌌": "en-US-AriaNeural",
-    "PixelPanda 🐼": "en-US-JennyNeural",
-    "QuantumQuack 🦆": "en-GB-SoniaNeural",
-    "StellarSquirrel 🐿️": "en-AU-NatashaNeural",
-    "GizmoGuru ⚙️": "en-CA-ClaraNeural",
-    "NebulaNinja 🌠": "en-US-GuyNeural",
-    "ByteBuster 💾": "en-GB-RyanNeural",
-    "GalacticGopher 🌍": "en-AU-WilliamNeural",
-    "RocketRaccoon 🚀": "en-CA-LiamNeural",
-    "EchoElf 🧝": "en-US-AriaNeural",
-    "PhantomFox 🦊": "en-US-JennyNeural",
-    "WittyWizard 🧙": "en-GB-SoniaNeural",
-    "LunarLlama 🌙": "en-AU-NatashaNeural",
-    "SolarSloth ☀️": "en-CA-ClaraNeural",
-    "AstroAlpaca 🦙": "en-US-GuyNeural",
-    "CyberCoyote 🐺": "en-GB-RyanNeural",
-    "MysticMoose 🦌": "en-AU-WilliamNeural",
-    "GlitchGnome 🧚": "en-CA-LiamNeural",
-    "VortexViper 🐍": "en-US-AriaNeural",
-    "ChronoChimp 🐒": "en-US-JennyNeural"
-}
-
-# Directories and files
-CHAT_DIR = "chat_logs"
-VOTE_DIR = "vote_logs"
-STATE_FILE = "user_state.txt"
-AUDIO_DIR = "audio_logs"
-HISTORY_DIR = "history_logs"
-os.makedirs(CHAT_DIR, exist_ok=True)
-os.makedirs(VOTE_DIR, exist_ok=True)
-os.makedirs(AUDIO_DIR, exist_ok=True)
+# Dictionary to store active connections
+active_connections = {}
+# Dictionary to store message history for each chat room (in-memory cache)
+chat_history = {}
+# Dictionary to track file modification times
+file_modification_times = {}
+# Dictionary to track users in each room/sector
+sector_users = {}
+# Global variables for event loop and queue
+main_event_loop = None
+message_queue = []
+
+# Grid dimensions for 2D sector map
+GRID_WIDTH = 10
+GRID_HEIGHT = 10
+
+# Directory to store persistent chat history
+HISTORY_DIR = "chat_history"
+
+# Create history directory if it doesn't exist
 os.makedirs(HISTORY_DIR, exist_ok=True)
 
-CHAT_FILE = os.path.join(CHAT_DIR, "global_chat.md")
-QUOTE_VOTES_FILE = os.path.join(VOTE_DIR, "quote_votes.md")
-MEDIA_VOTES_FILE = os.path.join(VOTE_DIR, "media_votes.md")
-HISTORY_FILE = os.path.join(HISTORY_DIR, "chat_history.md")
-
-# Unicode digits and fonts
-UNICODE_DIGITS = {i: f"{i}\uFE0F⃣" for i in range(10)}
-UNICODE_FONTS = [
-    ("Normal", lambda x: x),
-    ("Bold", lambda x: "".join(chr(ord(c) + 0x1D400 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D41A - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-]
-
-server_running = False
-server_task = None
-
-# Helper Functions
-def format_timestamp_prefix():
-    """📅 - Time Stamp Champ - Marks the clock, no flop!"""
-    return datetime.now().strftime("%Y%m%d_%H%M%S")
+# README.md file that won't be listed or deleted
+README_PATH = os.path.join(HISTORY_DIR, "README.md")
+if not os.path.exists(README_PATH):
+    with open(README_PATH, "w") as f:
+        f.write("# Chat History\n\nThis directory contains persistent chat history files.\n")
 
+# Get node name from URL or command line
 def get_node_name():
-    """🌐 - Naming Node with Code - Spins a name, oh so bold!"""
-    action = "🌐 - Naming Node with Code - Spins a name, oh so bold!"
-    username = st.session_state.get('username', 'System 🌟')
-    log_action(username, action)
     parser = argparse.ArgumentParser(description='Start a chat node with a specific name')
-    parser.add_argument('--node-name', type=str, default=None)
-    parser.add_argument('--port', type=int, default=8501)
+    parser.add_argument('--node-name', type=str, default=None, help='Name for this chat node')
+    parser.add_argument('--port', type=int, default=7860, help='Port to run the Gradio interface on')
+    
     args = parser.parse_args()
-    return args.node_name or f"node-{uuid.uuid4().hex[:8]}", args.port
-
-def log_action(username, action):
-    """📜 - Log Jog Blog - Tracks the deed, no greed!"""
-    if 'action_log' not in st.session_state:
-        st.session_state.action_log = {}
-    user_log = st.session_state.action_log.setdefault(username, {})
-    current_time = time.time()
-    user_log = {k: v for k, v in user_log.items() if current_time - v < 10}
-    st.session_state.action_log[username] = user_log
-    if action not in user_log:
-        with open(HISTORY_FILE, 'a') as f:
-            f.write(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] {username}: {action}\n")
-        user_log[action] = current_time
-
-async def save_chat_entry(username, message):
-    """📝 - Chat Snap Trap - Logs your yap, no cap! ✍️🧠"""
-    action = "📝 - Chat Snap Trap - Logs your yap, no cap! ✍️🧠"
-    await asyncio.to_thread(log_action, username, action)
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    entry = f"[{timestamp}] {username}: {message}"
-    await asyncio.to_thread(lambda: open(CHAT_FILE, 'a').write(f"{entry}\n"))
-    # Generate and save audio for the message
-    voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
-    audio_file = await async_edge_tts_generate(message, voice)
-    if audio_file:
-        with open(HISTORY_FILE, 'a') as f:
-            f.write(f"[{timestamp}] {username}: Audio generated - {audio_file}\n")
-
-async def load_chat():
-    """📖 - Chat Fetch Quest - Grabs the log, no jest!"""
-    action = "📖 - Chat Fetch Quest - Grabs the log, no jest!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    if not os.path.exists(CHAT_FILE):
-        await asyncio.to_thread(lambda: open(CHAT_FILE, 'w').write(f"# {START_ROOM} Chat\n\nWelcome to the cosmic hub - start chatting! 🎤\n"))
-    with open(CHAT_FILE, 'r') as f:
-        content = await asyncio.to_thread(f.read)
-    return content
-
-async def get_user_list(chat_content):
-    """👥 - Crew Clue Brew - Spots who’s who in the crew!"""
-    action = "👥 - Crew Clue Brew - Spots who’s who in the crew!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    users = set()
-    for line in chat_content.split('\n'):
-        if line.strip() and ': ' in line:
-            user = line.split(': ')[1].split(' ')[0]
-            users.add(user)
-    return sorted(list(users))
-
-async def has_joined_before(client_id, chat_content):
-    """🚪 - Join Check Trek - Sees who’s back, no wreck!"""
-    action = "🚪 - Join Check Trek - Sees who’s back, no wreck!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    return any(f"Client-{client_id} has joined" in line for line in chat_content.split('\n'))
-
-async def get_message_suggestions(chat_content, prefix):
-    """🔍 - Suggest Jest Chest - Finds old quips, the best!"""
-    action = "🔍 - Suggest Jest Chest - Finds old quips, the best!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    lines = chat_content.split('\n')
-    messages = [line.split(': ', 1)[1] for line in lines if ': ' in line and line.strip()]
-    return [msg for msg in messages if msg.lower().startswith(prefix.lower())][:5]
-
-async def save_vote(file, item, user_hash, username, comment=""):
-    """👍 - Vote Note Float - Cheers rise, we gloat!"""
-    action = "👍 - Vote Note Float - Cheers rise, we gloat!"
-    await asyncio.to_thread(log_action, username, action)
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    entry = f"[{timestamp}] {user_hash} voted for {item}"
-    await asyncio.to_thread(lambda: open(file, 'a').write(f"{entry}\n"))
-    await asyncio.to_thread(lambda: open(HISTORY_FILE, "a").write(f"- {timestamp} - User {user_hash} voted for {item}\n"))
-    chat_message = f"{username} upvoted: \"{item}\""
-    if comment:
-        chat_message += f" - {comment}"
-    await save_chat_entry(username, chat_message)
-
-async def load_votes(file):
-    """🏆 - Tally Rally Call - Counts the cheers, no stall!"""
-    action = "🏆 - Tally Rally Call - Counts the cheers, no stall!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    if not os.path.exists(file):
-        await asyncio.to_thread(lambda: open(file, 'w').write("# Vote Tally\n\nNo votes yet - get clicking! 🖱️\n"))
-    with open(file, 'r') as f:
-        lines = await asyncio.to_thread(f.read.strip().split, '\n')[2:]
-    votes = {}
-    user_votes = set()
-    for line in lines:
-        if line.strip() and 'voted for' in line:
-            user_hash = line.split('] ')[1].split(' voted for ')[0]
-            item = line.split('voted for ')[1]
-            vote_key = f"{user_hash}-{item}"
-            if vote_key not in user_votes:
-                votes[item] = votes.get(item, 0) + 1
-                user_votes.add(vote_key)
-    return votes
-
-async def generate_user_hash():
-    """🔑 - Hash Dash Bash - Crafts a code, so brash!"""
-    action = "🔑 - Hash Dash Bash - Crafts a code, so brash!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    if 'user_hash' not in st.session_state:
-        st.session_state.user_hash = hashlib.md5(str(random.getrandbits(128)).encode()).hexdigest()[:8]
-    return st.session_state.user_hash
-
-async def async_edge_tts_generate(text, voice, rate=0, pitch=0, file_format="mp3"):
-    """🎶 - Tune Moon Boom - Drops a beat, so groom!"""
-    action = "🎶 - Tune Moon Boom - Drops a beat, so groom!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    timestamp = format_timestamp_prefix()
-    filename = os.path.join(AUDIO_DIR, f"audio_{timestamp}_{random.randint(1000, 9999)}.mp3")
-    communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
-    await communicate.save(filename)
-    return filename if os.path.exists(filename) else None
-
-def play_and_download_audio(file_path):
-    """🔊 - Sound Pound Ground - Plays it loud, all around!"""
-    if file_path and os.path.exists(file_path):
-        st.audio(file_path)
-        with open(file_path, "rb") as f:
-            b64 = base64.b64encode(f.read()).decode()
-        dl_link = f'<a href="data:audio/mpeg;base64,{b64}" download="{os.path.basename(file_path)}">🎵 Download {os.path.basename(file_path)}</a>'
-        st.markdown(dl_link, unsafe_allow_html=True)
-
-async def save_pasted_image(image_data):
-    """📸 - Snap Cap Trap - Saves your pic, no flap!"""
-    action = "📸 - Snap Cap Trap - Saves your pic, no flap!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    timestamp = format_timestamp_prefix()
-    filename = f"paste_{timestamp}.png"
-    filepath = os.path.join('./', filename)
-    if ',' in image_data:
-        image_data = image_data.split(',')[1]
-    img_bytes = base64.b64decode(image_data)
-    img = Image.open(io.BytesIO(img_bytes))
-    await asyncio.to_thread(img.save, filepath, "PNG")
-    return filename
-
-async def get_video_html(video_path, width="100%"):
-    """🎥 - Reel Deal Steal - Plays your flick, so real!"""
-    action = "🎥 - Reel Deal Steal - Plays your flick, so real!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    video_url = f"data:video/mp4;base64,{base64.b64encode(await asyncio.to_thread(open, video_path, 'rb').read()).decode()}"
-    return f'<video width="{width}" controls autoplay muted loop><source src="{video_url}" type="video/mp4">Your browser does not support the video tag.</video>'
-
-async def get_audio_html(audio_path, width="100%"):
-    """🎶 - Tune Moon Boom - Drops a beat, so groom!"""
-    action = "🎶 - Tune Moon Boom - Drops a beat, so groom!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    audio_url = f"data:audio/mpeg;base64,{base64.b64encode(await asyncio.to_thread(open, audio_path, 'rb').read()).decode()}"
-    return f'<audio controls style="width: {width};"><source src="{audio_url}" type="audio/mpeg">Your browser does not support the audio element.</audio>'
-
-active_connections = {}
-
-async def websocket_handler(websocket, path):
-    """🌐 - Web Sock Jock - Links the chat, no block!"""
-    action = "🌐 - Web Sock Jock - Links the chat, no block!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
+    node_name = args.node_name
+    port = args.port
+    
+    # If no node name specified, generate a random one
+    if not node_name:
+        node_name = f"node-{uuid.uuid4().hex[:8]}"
+        
+    return node_name, port
+
+def get_room_history_file(room_id):
+    """Get the filename for a room's history."""
+    # Create timestamp-based log files
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return os.path.join(HISTORY_DIR, f"{room_id}_{timestamp}.jsonl")
+
+def get_all_room_history_files(room_id):
+    """Get all history files for a specific room."""
+    files = []
+    for file in os.listdir(HISTORY_DIR):
+        if file.startswith(f"{room_id}_") and file.endswith(".jsonl"):
+            files.append(os.path.join(HISTORY_DIR, file))
+    # Sort by modification time (newest first)
+    files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
+    return files
+
+def get_all_history_files():
+    """Get a list of all unique room IDs from history files, sorted by modification time (newest first)."""
     try:
-        client_id = str(uuid.uuid4())
-        room_id = "chat"
-        active_connections.setdefault(room_id, {})[client_id] = websocket
-        chat_content = await load_chat()
-        username = st.session_state.get('username', random.choice(list(FUN_USERNAMES.keys())))
-        if not await has_joined_before(client_id, chat_content):
-            await save_chat_entry(f"Client-{client_id}", f"{username} has joined {START_ROOM}!")
-        async for message in websocket:
-            parts = message.split('|', 1)
-            if len(parts) == 2:
-                username, content = parts
-                await save_chat_entry(username, content)
-                await broadcast_message(f"{username}|{content}", room_id)
-    except websockets.ConnectionClosed:
+        rooms = {}  # room_id -> (newest_file_path, mod_time)
+        
+        for file in os.listdir(HISTORY_DIR):
+            if file.endswith(".jsonl"):
+                file_path = os.path.join(HISTORY_DIR, file)
+                mod_time = os.path.getmtime(file_path)
+                
+                # Extract room_id from filename (format: roomid_timestamp.jsonl)
+                parts = file.split('_', 1)
+                if len(parts) > 0:
+                    room_id = parts[0]
+                    
+                    # Keep track of newest file for each room
+                    if room_id not in rooms or mod_time > rooms[room_id][1]:
+                        rooms[room_id] = (file_path, mod_time)
+        
+        # Convert to list and sort by modification time
+        history_files = [(room_id, file_path, mod_time) for room_id, (file_path, mod_time) in rooms.items()]
+        history_files.sort(key=lambda x: x[2], reverse=True)
+        
+        return history_files
+    except Exception as e:
+        logger.error(f"Error in get_all_history_files: {e}")
+        return []  # Return empty list on error
+
+def load_room_history(room_id):
+    """Load chat history for a room from all persistent storage files."""
+    if room_id not in chat_history:
+        chat_history[room_id] = []
+        
+        # Get all history files for this room
+        history_files = get_all_room_history_files(room_id)
+        
+        # Track file modification times
+        for file in history_files:
+            if file not in file_modification_times:
+                file_modification_times[file] = os.path.getmtime(file)
+        
+        # Load messages from all files
+        messages = []
+        for history_file in history_files:
+            try:
+                with open(history_file, 'r') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line:  # Skip empty lines
+                            try:
+                                data = json.loads(line)
+                                messages.append(data)
+                            except json.JSONDecodeError:
+                                logger.error(f"Error parsing JSON line in {history_file}")
+            except Exception as e:
+                logger.error(f"Error loading history from {history_file}: {e}")
+        
+        # Sort by timestamp
+        messages.sort(key=lambda x: x.get("timestamp", ""), reverse=False)
+        chat_history[room_id] = messages
+        
+        logger.info(f"Loaded {len(messages)} messages from {len(history_files)} files for room {room_id}")
+    
+    # Track users in this sector
+    if room_id not in sector_users:
+        sector_users[room_id] = set()
+    
+    return chat_history[room_id]
+
+def save_message_to_history(room_id, message):
+    """Save a single message to the newest history file for a room."""
+    # Get the newest history file or create a new one
+    history_files = get_all_room_history_files(room_id)
+    
+    if not history_files:
+        # Create a new file
+        history_file = get_room_history_file(room_id)
+    else:
+        # Use the newest file if it's less than 1 MB, otherwise create a new one
+        newest_file = history_files[0]
+        if os.path.getsize(newest_file) > 1024 * 1024:  # 1 MB
+            history_file = get_room_history_file(room_id)
+        else:
+            history_file = newest_file
+    
+    try:
+        # Append the message as a single line of JSON
+        with open(history_file, 'a') as f:
+            f.write(json.dumps(message) + '\n')
+        
+        # Update modification time
+        file_modification_times[history_file] = os.path.getmtime(history_file)
+        
+        logger.debug(f"Saved message to {history_file}")
+    except Exception as e:
+        logger.error(f"Error saving message to {history_file}: {e}")
+
+def check_for_new_messages():
+    """Check for new messages in all history files."""
+    updated_rooms = set()
+    
+    # Check all files in the history directory
+    for file in os.listdir(HISTORY_DIR):
+        if file.endswith(".jsonl"):
+            file_path = os.path.join(HISTORY_DIR, file)
+            current_mtime = os.path.getmtime(file_path)
+            
+            # Check if this file is new or has been modified
+            if file_path not in file_modification_times or current_mtime > file_modification_times[file_path]:
+                # Extract room_id from filename
+                parts = file.split('_', 1)
+                if len(parts) > 0:
+                    room_id = parts[0]
+                    updated_rooms.add(room_id)
+                    
+                # Update tracked modification time
+                file_modification_times[file_path] = current_mtime
+    
+    # Reload history for updated rooms
+    for room_id in updated_rooms:
+        if room_id in chat_history:
+            # Remember we had this room loaded
+            old_history_len = len(chat_history[room_id])
+            # Clear and reload
+            chat_history[room_id] = []
+            load_room_history(room_id)
+            new_history_len = len(chat_history[room_id])
+            
+            if new_history_len > old_history_len:
+                logger.info(f"Found {new_history_len - old_history_len} new messages for room {room_id}")
+    
+    return updated_rooms
+
+def get_sector_coordinates(room_id):
+    """Convert a room ID to grid coordinates, or assign new ones."""
+    try:
+        # Try to parse room ID as "x,y"
+        if ',' in room_id:
+            x, y = map(int, room_id.split(','))
+            return max(0, min(x, GRID_WIDTH-1)), max(0, min(y, GRID_HEIGHT-1))
+    except:
         pass
-    finally:
-        if room_id in active_connections and client_id in active_connections[room_id]:
-            del active_connections[room_id][client_id]
+    
+    # Hash the room_id string to get stable coordinates
+    hash_val = hash(room_id)
+    x = abs(hash_val) % GRID_WIDTH
+    y = abs(hash_val >> 8) % GRID_HEIGHT
+    
+    return x, y
+
+def generate_sector_map():
+    """Generate an ASCII representation of the sector map."""
+    # Initialize empty grid
+    grid = [[' ' for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
+    
+    # Place active rooms with user counts
+    for room_id, users in sector_users.items():
+        if users:  # Only show rooms with users
+            x, y = get_sector_coordinates(room_id)
+            user_count = len(users)
+            grid[y][x] = str(min(user_count, 9)) if user_count < 10 else '+'
+    
+    # Create ASCII representation
+    header = '  ' + ''.join([str(i % 10) for i in range(GRID_WIDTH)])
+    map_str = header + '\n'
+    
+    for y in range(GRID_HEIGHT):
+        row = f"{y % 10}|"
+        for x in range(GRID_WIDTH):
+            row += grid[y][x]
+        row += '|'
+        map_str += row + '\n'
+    
+    footer = '  ' + ''.join([str(i % 10) for i in range(GRID_WIDTH)])
+    map_str += footer
+    
+    return f"```\n{map_str}\n```\n\nLegend: Number indicates users in sector. '+' means 10+ users."
+
+def list_available_rooms():
+    """List all available chat rooms with their last activity time and user count."""
+    try:
+        history_files = get_all_history_files()
+        
+        if not history_files:
+            return "No chat rooms available yet. Create one by joining a room!"
+        
+        room_list = "### Available Chat Rooms (Sectors)\n\n"
+        room_list += "| Room ID | Sector | Users | Last Activity |\n"
+        room_list += "|---------|--------|-------|---------------|\n"
+        
+        for room_id, file_path, mod_time in history_files:
+            x, y = get_sector_coordinates(room_id)
+            user_count = len(sector_users.get(room_id, set()))
+            last_activity = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M:%S")
+            room_list += f"| {room_id} | ({x},{y}) | {user_count} | {last_activity} |\n"
+        
+        room_list += "\n\n### Sector Map\n\n" + generate_sector_map()
+        
+        return room_list
+    except Exception as e:
+        logger.error(f"Error in list_available_rooms: {e}")
+        return f"Error listing rooms: {str(e)}"
 
 async def broadcast_message(message, room_id):
-    """📢 - Shout Out Bout - Blasts the word, no doubt!"""
-    action = "📢 - Shout Out Bout - Blasts the word, no doubt!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
+    """Broadcast a message to all clients in a room."""
     if room_id in active_connections:
-        disconnected = []
-        for client_id, ws in active_connections[room_id].items():
+        disconnected_clients = []
+        
+        for client_id, websocket in active_connections[room_id].items():
             try:
-                await ws.send(message)
-            except websockets.ConnectionClosed:
-                disconnected.append(client_id)
-        for client_id in disconnected:
+                await websocket.send(json.dumps(message))
+            except websockets.exceptions.ConnectionClosed:
+                disconnected_clients.append(client_id)
+        
+        # Clean up disconnected clients
+        for client_id in disconnected_clients:
             del active_connections[room_id][client_id]
 
-async def run_websocket_server():
-    """🖥️ - Server Ferver Verve - Spins the web, with nerve!"""
-    action = "🖥️ - Server Ferver Verve - Spins the web, with nerve!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    global server_running, server_task
-    if not server_running:
-        server = await websockets.serve(websocket_handler, '0.0.0.0', 8765)
-        server_running = True
-        await server.wait_closed()
-
-async def process_voice_input(audio_bytes):
-    """🎤 - Voice Choice Rejoice - Speaks your mind, oh boy!"""
-    action = "🎤 - Voice Choice Rejoice - Speaks your mind, oh boy!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    if audio_bytes:
-        # Simple placeholder for speech-to-text (requires additional library like `speech_recognition`)
-        # For now, we'll simulate text input from audio
-        text = "Voice input simulation"  # Replace with actual speech-to-text logic
-        await save_chat_entry(username, text)
-
-async def create_streamlit_interface():
-    """🎨 - UI Brew Crew - Builds the view, so new!"""
-    action = "🎨 - UI Brew Crew - Builds the view, so new!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-
-    if 'username' not in st.session_state:
-        chat_content = await load_chat()
-        available_names = [name for name in FUN_USERNAMES if not any(f"{name} has joined" in line for line in chat_content.split('\n'))]
-        st.session_state.username = random.choice(available_names) if available_names else random.choice(list(FUN_USERNAMES.keys()))
-
-    if 'refresh_rate' not in st.session_state:
-        st.session_state.refresh_rate = 5
-    if 'timer_start' not in st.session_state:
-        st.session_state.timer_start = time.time()
-    if 'quote_line' not in st.session_state:
-        st.session_state.quote_line = None
-    if 'pasted_image_data' not in st.session_state:
-        st.session_state.pasted_image_data = None
-    if 'message_text' not in st.session_state:
-        st.session_state.message_text = ""
-    if 'audio_cache' not in st.session_state:
-        st.session_state.audio_cache = {}
-    if 'chat_history' not in st.session_state:
-        st.session_state.chat_history = []
-
-    st.markdown("""
-        <style>
-        .chat-box {font-family: monospace; background: #1e1e1e; color: #d4d4d4; padding: 10px; border-radius: 5px; height: 300px; overflow-y: auto;}
-        .timer {font-size: 24px; color: #ffcc00; text-align: center; animation: pulse 1s infinite;}
-        @keyframes pulse {0% {transform: scale(1);} 50% {transform: scale(1.1);} 100% {transform: scale(1);}}
-        #paste-target {border: 2px dashed #ccc; padding: 20px; text-align: center; cursor: pointer;}
-        </style>
-    """, unsafe_allow_html=True)
-
-    st.title(f"🤖🧠MMO {st.session_state.username}📝🔬")
-    st.markdown(f"Welcome to {START_ROOM} - chat, vote, upload, paste images, and enjoy quoting! 🎉")
-
-    # Voice Input
-    audio_bytes = audio_recorder()
-    if audio_bytes:
-        await process_voice_input(audio_bytes)
-        st.rerun()
-
-    # Chat Section
-    st.subheader(f"{START_ROOM} Chat 💬")
-    chat_content = await load_chat()
-    chat_lines = chat_content.split('\n')
-    chat_votes = await load_votes(QUOTE_VOTES_FILE)
-    for i, line in enumerate(chat_lines):
-        if line.strip() and ': ' in line:
-            col1, col2, col3 = st.columns([4, 1, 1])
-            with col1:
-                st.markdown(line)
-                username = line.split(': ')[1].split(' ')[0]
-                audio_file = None
-                cache_key = f"{line}_{FUN_USERNAMES.get(username, 'en-US-AriaNeural')}"
-                if cache_key in st.session_state.audio_cache:
-                    audio_file = st.session_state.audio_cache[cache_key]
-                else:
-                    audio_file = await async_edge_tts_generate(line.split(': ', 1)[1], FUN_USERNAMES.get(username, "en-US-AriaNeural"))
-                    st.session_state.audio_cache[cache_key] = audio_file
-                if audio_file:
-                    play_and_download_audio(audio_file)
-            with col2:
-                vote_count = chat_votes.get(line.split('. ')[1] if '. ' in line else line, 0)
-                if st.button(f"👍 {vote_count}", key=f"chat_vote_{i}"):
-                    comment = st.session_state.message_text
-                    await save_vote(QUOTE_VOTES_FILE, line.split('. ')[1] if '. ' in line else line, await generate_user_hash(), st.session_state.username, comment)
-                    if st.session_state.pasted_image_data:
-                        filename = await save_pasted_image(st.session_state.pasted_image_data)
-                        if filename:
-                            await save_chat_entry(st.session_state.username, f"Pasted image: {filename}")
-                            st.session_state.pasted_image_data = None
-                    st.session_state.message_text = ''
-                    st.rerun()
-            with col3:
-                if st.button("📢 Quote", key=f"quote_{i}"):
-                    st.session_state.quote_line = line
-                    st.rerun()
-
-    # Quoting Section
-    if 'quote_line' in st.session_state:
-        st.markdown(f"### Quoting: {st.session_state.quote_line}")
-        quote_response = st.text_area("Add your response", key="quote_response")
-        if st.button("Send Quote 🚀", key="send_quote"):
-            async def process_quote():
-                """📢 - Quote Float Boat - Echoes chat, we gloat!"""
-                action = "📢 - Quote Float Boat - Echoes chat, we gloat!"
-                await asyncio.to_thread(log_action, st.session_state.username, action)
-                markdown_response = f"### Quote Response\n- **Original**: {st.session_state.quote_line}\n- **{st.session_state.username} Replies**: {quote_response}"
-                if st.session_state.pasted_image_data:
-                    filename = await save_pasted_image(st.session_state.pasted_image_data)
-                    if filename:
-                        markdown_response += f"\n- **Image**: ![Pasted Image]({filename})"
-                        st.session_state.pasted_image_data = None
-                await save_chat_entry(st.session_state.username, markdown_response)
-            await process_quote()
-            del st.session_state.quote_line
-            st.session_state.message_text = ''
-            st.rerun()
-
-    # Username Change Dropdown
-    new_username = st.selectbox("Change Name", [""] + list(FUN_USERNAMES.keys()), index=0)
-    if new_username and new_username != st.session_state.username:
-        await save_chat_entry("System 🌟", f"{st.session_state.username} changed name to {new_username}")
-        st.session_state.username = new_username
-        st.rerun()
-
-    # Message Input
-    message = st.text_input(f"Message as {st.session_state.username}", key="message_input", value=st.session_state.message_text, on_change=lambda: st.session_state.update(message_text=st.session_state.message_input))
-    if st.button("Send 🚀", key="send_button") and message.strip():
-        await save_chat_entry(st.session_state.username, message)
-        if st.session_state.pasted_image_data:
-            filename = await save_pasted_image(st.session_state.pasted_image_data)
-            if filename:
-                await save_chat_entry(st.session_state.username, f"Pasted image: {filename}")
-                st.session_state.pasted_image_data = None
-        st.session_state.message_text = ''
-        st.rerun()
+async def start_websocket_server(host='0.0.0.0', port=8765):
+    """Start the WebSocket server."""
+    server = await websockets.serve(websocket_handler, host, port)
+    logger.info(f"WebSocket server started on ws://{host}:{port}")
+    return server
+
+def send_message(message, username, room_id):
+    """Function to send a message from the Gradio interface."""
+    if not message.strip():
+        return None
+    
+    global message_queue
+    
+    msg_data = {
+        "type": "chat",
+        "content": message,
+        "username": username,
+        "room_id": room_id
+    }
+    
+    # Add to queue for processing by the main loop
+    message_queue.append(msg_data)
+    
+    # Format the message for display in the UI
+    formatted_msg = f"{username}: {message}"
+    return formatted_msg
+
+def send_clear_command():
+    """Send a command to clear all chat history."""
+    global message_queue
+    
+    msg_data = {
+        "type": "command",
+        "command": "clear_history",
+        "username": "System"
+    }
+    
+    # Add to queue for processing by the main loop
+    message_queue.append(msg_data)
+    
+    return "🧹 Clearing all chat history..."
+
+async def clear_all_history():
+    """Clear all chat history for all rooms."""
+    global chat_history, sector_users
+    
+    # Clear in-memory history
+    chat_history = {}
+    sector_users = {}
+    
+    # Delete all history files except README.md
+    for file in os.listdir(HISTORY_DIR):
+        if file.endswith(".jsonl"):
+            try:
+                os.remove(os.path.join(HISTORY_DIR, file))
+            except Exception as e:
+                logger.error(f"Error removing file {file}: {e}")
+    
+    # Broadcast clear message to all rooms
+    clear_msg = {
+        "type": "system",
+        "content": "🧹 All chat history has been cleared by a user",
+        "timestamp": datetime.now().isoformat(),
+        "sender": "system"
+    }
+    
+    for room_id in list(active_connections.keys()):
+        clear_msg["room_id"] = room_id
+        await broadcast_message(clear_msg, room_id)
+    
+    logger.info("All chat history cleared")
+    return "All chat history cleared"
+
+def join_room(room_id, chat_history_output):
+    """Join a specific chat room."""
+    if not room_id.strip():
+        return "Please enter a valid room ID", chat_history_output
+    
+    # Sanitize the room ID
+    room_id = urllib.parse.quote(room_id.strip())
+    
+    # Load room history from persistent storage
+    history = load_room_history(room_id)
+    
+    # Get sector coordinates
+    x, y = get_sector_coordinates(room_id)
+    
+    # Format existing messages
+    formatted_history = [f"You are now in Sector ({x},{y}) - Room ID: {room_id}"]
+    formatted_history.append(f"Sector Map:\n{generate_sector_map()}")
+    
+    for msg in history:
+        if msg.get("type") == "chat":
+            sender_node = f" [{msg.get('sender_node', 'unknown')}]" if "sender_node" in msg else ""
+            time_str = ""
+            if "timestamp" in msg:
+                try:
+                    dt = datetime.fromisoformat(msg["timestamp"])
+                    time_str = f"[{dt.strftime('%H:%M:%S')}] "
+                except:
+                    pass
+            formatted_history.append(f"{time_str}{msg.get('username', 'Anonymous')}{sender_node}: {msg.get('content', '')}")
+        elif msg.get("type") == "system":
+            formatted_history.append(f"System: {msg.get('content', '')}")
+    
+    return f"Joined room: {room_id}", formatted_history
 
-    # Paste Target
-    paste_component = components.html(
-        """
-        <div id="paste-target">Paste an image here (Ctrl+V)</div>
-        <script>
-        const pasteTarget = document.getElementById('paste-target');
-        pasteTarget.addEventListener('paste', (event) => {
-            const items = (event.clipboardData || window.clipboardData).items;
-            for (let i = 0; i < items.length; i++) {
-                if (items[i].type.indexOf('image') !== -1) {
-                    const blob = items[i].getAsFile();
-                    const reader = new FileReader();
-                    reader.onload = (e) => {
-                        window.parent.postMessage({
-                            type: 'streamlit:setComponentValue',
-                            value: e.target.result
-                        }, '*');
-                        pasteTarget.innerHTML = '<p>Image pasted! Processing...</p>';
-                    };
-                    reader.readAsDataURL(blob);
+async def websocket_handler(websocket, path):
+    """Handle WebSocket connections."""
+    client_id = str(uuid.uuid4())
+    room_id = "default"  # Default initialization to avoid reference errors
+    
+    try:
+        # Extract room_id from path if present
+        path_parts = path.strip('/').split('/')
+        room_id = path_parts[0] if path_parts else "default"
+        
+        # Register the new client
+        if room_id not in active_connections:
+            active_connections[room_id] = {}
+        
+        active_connections[room_id][client_id] = websocket
+        
+        # Add user to sector map
+        if room_id not in sector_users:
+            sector_users[room_id] = set()
+        sector_users[room_id].add(client_id)
+        
+        # Get sector coordinates
+        x, y = get_sector_coordinates(room_id)
+        
+        # Load or initialize chat history
+        room_history = load_room_history(room_id)
+        
+        # Send welcome message
+        welcome_msg = {
+            "type": "system",
+            "content": f"Welcome to room '{room_id}' (Sector {x},{y})! Connected from node '{NODE_NAME}'",
+            "timestamp": datetime.now().isoformat(),
+            "sender": "system",
+            "room_id": room_id
+        }
+        await websocket.send(json.dumps(welcome_msg))
+        
+        # Send sector map
+        map_msg = {
+            "type": "system",
+            "content": f"Sector Map:\n{generate_sector_map()}",
+            "timestamp": datetime.now().isoformat(),
+            "sender": "system",
+            "room_id": room_id
+        }
+        await websocket.send(json.dumps(map_msg))
+        
+        # Send chat history
+        for msg in room_history:
+            await websocket.send(json.dumps(msg))
+        
+        # Broadcast join notification
+        join_msg = {
+            "type": "system",
+            "content": f"User joined the room (Sector {x},{y}) - {len(sector_users[room_id])} users now present",
+            "timestamp": datetime.now().isoformat(),
+            "sender": "system",
+            "room_id": room_id
+        }
+        await broadcast_message(join_msg, room_id)
+        save_message_to_history(room_id, join_msg)
+        
+        logger.info(f"New client {client_id} connected to room {room_id} (Sector {x},{y})")
+        
+        # Handle messages from this client
+        async for message in websocket:
+            try:
+                data = json.loads(message)
+                
+                # Check for clear command
+                if data.get("type") == "command" and data.get("command") == "clear_history":
+                    result = await clear_all_history()
+                    continue
+                
+                # Check for map request
+                if data.get("type") == "command" and data.get("command") == "show_map":
+                    map_msg = {
+                        "type": "system",
+                        "content": f"Sector Map:\n{generate_sector_map()}",
+                        "timestamp": datetime.now().isoformat(),
+                        "sender": "system",
+                        "room_id": room_id
+                    }
+                    await websocket.send(json.dumps(map_msg))
+                    continue
+                
+                # Add metadata to the message
+                data["timestamp"] = datetime.now().isoformat()
+                data["sender_node"] = NODE_NAME
+                data["room_id"] = room_id
+                
+                # Store in history
+                chat_history[room_id].append(data)
+                if len(chat_history[room_id]) > 500:  # Increased limit to 500 messages
+                    chat_history[room_id] = chat_history[room_id][-500:]
+                
+                # Save to persistent storage
+                save_message_to_history(room_id, data)
+                
+                # Broadcast to all clients in the room
+                await broadcast_message(data, room_id)
+                
+            except json.JSONDecodeError:
+                error_msg = {
+                    "type": "error",
+                    "content": "Invalid JSON format",
+                    "timestamp": datetime.now().isoformat(),
+                    "sender": "system",
+                    "room_id": room_id
                 }
+                await websocket.send(json.dumps(error_msg))
+    
+    except websockets.exceptions.ConnectionClosed:
+        logger.info(f"Client {client_id} disconnected from room {room_id}")
+    finally:
+        # Remove the client when disconnected
+        if room_id in active_connections and client_id in active_connections[room_id]:
+            del active_connections[room_id][client_id]
+            
+            # Remove user from sector map
+            if room_id in sector_users and client_id in sector_users[room_id]:
+                sector_users[room_id].remove(client_id)
+            
+            # Get sector coordinates
+            x, y = get_sector_coordinates(room_id)
+            
+            # Broadcast leave notification
+            leave_msg = {
+                "type": "system",
+                "content": f"User left the room (Sector {x},{y}) - {len(sector_users.get(room_id, set()))} users remaining",
+                "timestamp": datetime.now().isoformat(),
+                "sender": "system",
+                "room_id": room_id
             }
-            event.preventDefault();
-        });
-        </script>
-        """,
-        height=100
-    )
-
-    # Media Section
-    st.subheader("Media Gallery 🎨🎶🎥")
-    uploaded_file = st.file_uploader("Upload Media", type=['png', 'jpg', 'mp3', 'mp4'])
-    if uploaded_file:
-        file_path = os.path.join('./', uploaded_file.name)
-        await asyncio.to_thread(lambda: open(file_path, 'wb').write(uploaded_file.getbuffer()))
-        st.success(f"Uploaded {uploaded_file.name}")
-
-    media_files = glob.glob("./*.png") + glob.glob("./*.jpg") + glob.glob("./*.mp3") + glob.glob("./*.mp4")
-    if media_files:
-        cols = st.columns(3)
-        media_votes = await load_votes(MEDIA_VOTES_FILE)
-        for idx, media_file in enumerate(media_files):
-            vote_count = media_votes.get(media_file, 0)
-            if vote_count > 0:
-                with cols[idx % 3]:
-                    if media_file.endswith(('.png', '.jpg')):
-                        st.image(media_file, use_container_width=True)
-                    elif media_file.endswith('.mp3'):
-                        st.markdown(await get_audio_html(media_file), unsafe_allow_html=True)
-                    elif media_file.endswith('.mp4'):
-                        st.markdown(await get_video_html(media_file), unsafe_allow_html=True)
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        if st.button(f"👍 {vote_count}", key=f"media_vote_{idx}"):
-                            comment = st.session_state.message_text
-                            await save_vote(MEDIA_VOTES_FILE, media_file, await generate_user_hash(), st.session_state.username, comment)
-                            if st.session_state.pasted_image_data:
-                                filename = await save_pasted_image(st.session_state.pasted_image_data)
-                                if filename:
-                                    await save_chat_entry(st.session_state.username, f"Pasted image: {filename}")
-                                    st.session_state.pasted_image_data = None
-                            st.session_state.message_text = ''
-                            st.rerun()
-                    with col2:
-                        if st.button("🗑️", key=f"media_delete_{idx}"):
-                            await asyncio.to_thread(os.remove, media_file)
-                            st.rerun()
-
-    # Refresh Timer
-    st.subheader("Refresh ⏳")
-    refresh_rate = st.slider("Refresh Rate", 1, 300, st.session_state.refresh_rate)
-    st.session_state.refresh_rate = refresh_rate
-    timer_placeholder = st.empty()
-    for i in range(st.session_state.refresh_rate, -1, -1):
-        font_name, font_func = random.choice(UNICODE_FONTS)
-        countdown_str = "".join(UNICODE_DIGITS[int(d)] for d in str(i)) if i < 10 else font_func(str(i))
-        timer_placeholder.markdown(f"<p class='timer'>⏳ {font_func('Refresh in:')} {countdown_str}</p>", unsafe_allow_html=True)
-        await asyncio.sleep(1)
-    st.rerun()
-
-    # Sidebar History
-    st.sidebar.subheader("Chat History 📜")
-    with open(HISTORY_FILE, 'r') as f:
-        history_content = f.read()
-    st.sidebar.markdown(history_content)
+            await broadcast_message(leave_msg, room_id)
+            save_message_to_history(room_id, leave_msg)
+            
+            # Clean up empty rooms (but keep history)
+            if not active_connections[room_id]:
+                del active_connections[room_id]
+
+async def process_message_queue():
+    """Process messages in the queue and broadcast them."""
+    global message_queue
+    
+    while True:
+        # Check if there are messages to process
+        if message_queue:
+            # Get the oldest message
+            msg_data = message_queue.pop(0)
+            
+            # Check for clear command
+            if msg_data.get("type") == "command" and msg_data.get("command") == "clear_history":
+                await clear_all_history()
+            elif "room_id" in msg_data:
+                # Regular message - add to history and broadcast
+                room_id = msg_data["room_id"]
+                
+                # Add timestamp if not present
+                if "timestamp" not in msg_data:
+                    msg_data["timestamp"] = datetime.now().isoformat()
+                
+                # Add sender node if not present
+                if "sender_node" not in msg_data:
+                    msg_data["sender_node"] = NODE_NAME
+                
+                # Store in memory history
+                if room_id not in chat_history:
+                    chat_history[room_id] = []
+                chat_history[room_id].append(msg_data)
+                
+                # Save to file
+                save_message_to_history(room_id, msg_data)
+                
+                # Broadcast to all clients in the room
+                await broadcast_message(msg_data, room_id)
+        
+        # Check for file changes every second
+        updated_rooms = check_for_new_messages()
+        
+        # If any rooms were updated, notify clients
+        for room_id in updated_rooms:
+            if room_id in active_connections:
+                # Find the newest messages that clients might not have seen
+                # This is a simplification - in a real app, you'd track which messages each client has seen
+                if room_id in chat_history and chat_history[room_id]:
+                    # Get the latest 5 messages as an example
+                    latest_messages = chat_history[room_id][-5:]
+                    for msg in latest_messages:
+                        # Only broadcast messages from other nodes (to avoid duplicates)
+                        if msg.get("sender_node") != NODE_NAME:
+                            await broadcast_message(msg, room_id)
+        
+        # Sleep to avoid busy-waiting
+        await asyncio.sleep(1.0)  # Check every second
+
+def create_gradio_interface():
+    """Create and return the Gradio interface."""
+    with gr.Blocks(title=f"Chat Node: {NODE_NAME}") as interface:
+        gr.Markdown(f"# Chat Node: {NODE_NAME}")
+        gr.Markdown("Join a room by entering a room ID below or create a new one.")
+        
+        # Room list and management
+        with gr.Row():
+            with gr.Column(scale=3):
+                room_list = gr.Markdown(value="Loading available rooms...")
+                refresh_button = gr.Button("🔄 Refresh Room List")
+            with gr.Column(scale=1):
+                clear_button = gr.Button("🧹 Clear All Chat History", variant="stop")
+        
+        # Join room controls with 2D grid input
+        with gr.Row():
+            with gr.Column(scale=2):
+                room_id_input = gr.Textbox(label="Room ID", placeholder="Enter room ID or use x,y coordinates")
+                join_button = gr.Button("Join Room")
+            with gr.Column(scale=1):
+                with gr.Row():
+                    x_coord = gr.Number(label="X", value=0, minimum=0, maximum=GRID_WIDTH-1, step=1)
+                    y_coord = gr.Number(label="Y", value=0, minimum=0, maximum=GRID_HEIGHT-1, step=1)
+                grid_join_button = gr.Button("Join by Coordinates")
+        
+        # Chat area with multiline support
+        chat_history_output = gr.Textbox(label="Chat History", lines=20, max_lines=20)
+        
+        # Message controls with multiline support
+        with gr.Row():
+            username_input = gr.Textbox(label="Username", placeholder="Enter your username", value="User")
+            with gr.Column(scale=3):
+                message_input = gr.Textbox(
+                    label="Message", 
+                    placeholder="Type your message here. Press Shift+Enter for new line, Enter to send.", 
+                    lines=3
+                )
+            with gr.Column(scale=1):
+                send_button = gr.Button("Send")
+                map_button = gr.Button("🗺️ Show Map")
+        
+        # Current room display
+        current_room_display = gr.Textbox(label="Current Room", value="Not joined any room yet")
+        
+        # Event handlers
+        refresh_button.click(
+            list_available_rooms,
+            inputs=[],
+            outputs=[room_list]
+        )
+        
+        clear_button.click(
+            send_clear_command,
+            inputs=[],
+            outputs=[room_list]
+        )
+        
+        def join_by_coordinates(x, y):
+            """Join a room using grid coordinates."""
+            room_id = f"{int(x)},{int(y)}"
+            return room_id
+        
+        # Link grid coordinates to room ID
+        grid_join_button.click(
+            join_by_coordinates,
+            inputs=[x_coord, y_coord],
+            outputs=[room_id_input]
+        ).then(
+            join_room,
+            inputs=[room_id_input, chat_history_output],
+            outputs=[current_room_display, chat_history_output]
+        )
+        
+        join_button.click(
+            join_room,
+            inputs=[room_id_input, chat_history_output],
+            outputs=[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", message
+            
+            actual_room_id = room_id.replace("Joined room: ", "").strip()
+            
+            # Support for multi-line messages
+            message_lines = message.strip().split("\n")
+            formatted_msg = ""
+            
+            for line in message_lines:
+                if line.strip():  # Skip empty lines
+                    sent_msg = send_message(line.strip(), username, actual_room_id)
+                    if sent_msg:
+                        formatted_msg += sent_msg + "\n"
+            
+            if formatted_msg:
+                return "", formatted_msg
+            return message, None
+        
+        send_button.click(
+            send_and_clear,
+            inputs=[message_input, username_input, current_room_display],
+            outputs=[message_input, chat_history_output]
+        )
+        
+        def show_sector_map(room_id):
+            if not room_id.startswith("Joined room:"):
+                return "Please join a room first to view the map"
+            
+            return generate_sector_map()
+        
+        map_button.click(
+            show_sector_map,
+            inputs=[current_room_display],
+            outputs=[chat_history_output]
+        )
+        
+        # Handle Enter key for sending, Shift+Enter for new line
+        def on_message_submit(message, username, room_id):
+            # Simply call send_and_clear
+            return send_and_clear(message, username, room_id)
+        
+        message_input.submit(
+            on_message_submit,
+            inputs=[message_input, username_input, current_room_display],
+            outputs=[message_input, chat_history_output]
+        )
+        
+        # On load, populate room list
+        interface.load(
+            list_available_rooms,
+            inputs=[],
+            outputs=[room_list]
+        )
+    
+    return interface
 
 async def main():
-    """🎮 - Game Fame Claim - Starts the fun, no shame!"""
-    action = "🎮 - Game Fame Claim - Starts the fun, no shame!"
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, action)
-    global NODE_NAME, server_task
-    NODE_NAME, port = get_node_name()  # Synchronous call, no await needed
-    if server_task is None:
-        server_task = asyncio.create_task(run_websocket_server())
-    await create_streamlit_interface()
+    """Main function to start the application."""
+    global NODE_NAME, main_event_loop
+    NODE_NAME, port = get_node_name()
+    
+    # Store the main event loop for later use
+    main_event_loop = asyncio.get_running_loop()
+    
+    # Start WebSocket server
+    server = await start_websocket_server()
+    
+    # Start message queue processor
+    asyncio.create_task(process_message_queue())
+    
+    # Create and launch Gradio interface
+    interface = create_gradio_interface()
+    
+    # Custom middleware to extract node name from URL query parameters
+    from starlette.middleware.base import BaseHTTPMiddleware
+    
+    class NodeNameMiddleware(BaseHTTPMiddleware):
+        async def dispatch(self, request, call_next):
+            global NODE_NAME
+            query_params = dict(request.query_params)
+            if "node_name" in query_params:
+                NODE_NAME = query_params["node_name"]
+                logger.info(f"Node name set to {NODE_NAME} from URL parameter")
+            
+            response = await call_next(request)
+            return response
+    
+    # Apply middleware
+    app = gr.routes.App.create_app(interface)
+    app.add_middleware(NodeNameMiddleware)
+    
+    # Launch with the modified app
+    gr.routes.mount_gradio_app(app, interface, path="/")
+    
+    # Run the FastAPI app with uvicorn
+    import uvicorn
+    config = uvicorn.Config(app, host="0.0.0.0", port=port)
+    server = uvicorn.Server(config)
+    
+    logger.info(f"Starting Gradio interface on http://0.0.0.0:{port} with node name '{NODE_NAME}'")
+    logger.info("Starting message queue processor")
+    
+    # Start the server
+    await server.serve()
 
 if __name__ == "__main__":
     asyncio.run(main())