Update app.py

app.py

@@ -1,824 +1,545 @@
-import gradio as gr
+import streamlit as st
 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
-from pathlib import Path
+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
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler(sys.stdout)]
+# 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"
 )
-logger = logging.getLogger("chat-node")
 
-# 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
+# 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)
 os.makedirs(HISTORY_DIR, exist_ok=True)
 
-# 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")
+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")
 
-# 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, help='Name for this chat node')
-    parser.add_argument('--port', type=int, default=7860, help='Port to run the Gradio interface on')
-    parser.add_argument('--ws-port', type=int, default=8765, help='Port to run the WebSocket server on')
-    
+    parser.add_argument('--node-name', type=str, default=None)
+    parser.add_argument('--port', type=int, default=8501)
     args = parser.parse_args()
-    node_name = args.node_name
-    port = args.port
-    ws_port = args.ws_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, ws_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:
-        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."""
+    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)
     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:
+        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:
         pass
-    
-    # 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)}"
+    finally:
+        if room_id in active_connections and client_id in active_connections[room_id]:
+            del active_connections[room_id][client_id]
 
 async def broadcast_message(message, room_id):
-    """Broadcast a message to all clients in a room."""
+    """📢 - 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)
     if room_id in active_connections:
-        disconnected_clients = []
-        
-        for client_id, websocket in active_connections[room_id].items():
+        disconnected = []
+        for client_id, ws in active_connections[room_id].items():
             try:
-                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:
+                await ws.send(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):
-    """Start the WebSocket server."""
-    try:
-        server = await websockets.serve(websocket_handler, host, port)
-        logger.info(f"WebSocket server started on ws://{host}:{port}")
-        return server
-    except OSError as e:
-        if e.errno == 98:  # Address already in use
-            logger.warning(f"Port {port} already in use, trying port {port+1}")
-            # Try a different port
-            return await start_websocket_server(host, port+1)
-        else:
-            # If it's a different error, re-raise it
-            raise
-
-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
+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 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
+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()
+
+    # 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);
                 }
-                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
             }
-            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
+            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)
 
 async def main():
-    """Main function to start the application."""
-    global NODE_NAME, main_event_loop
-    NODE_NAME, port, ws_port = get_node_name()
-    
-    # Store the main event loop for later use
-    main_event_loop = asyncio.get_running_loop()
-    
-    # Start WebSocket server
-    try:
-        server = await start_websocket_server(port=ws_port)
-        
-        # 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)
-        
-        # Try to create the server with retries for port conflicts
-        server_started = False
-        max_retries = 5
-        current_port = port
-        
-        for attempt in range(max_retries):
-            try:
-                config = uvicorn.Config(app, host="0.0.0.0", port=current_port)
-                server = uvicorn.Server(config)
-                logger.info(f"Starting Gradio interface on http://0.0.0.0:{current_port} with node name '{NODE_NAME}'")
-                logger.info("Starting message queue processor")
-                await server.serve()
-                server_started = True
-                break
-            except OSError as e:
-                if e.errno == 98:  # Address already in use
-                    current_port += 1
-                    logger.warning(f"Port {current_port-1} already in use, trying port {current_port}")
-                else:
-                    raise
-        
-        if not server_started:
-            logger.error(f"Failed to start server after {max_retries} attempts")
-            
-    except Exception as e:
-        logger.error(f"Error in main: {e}")
-        raise
+    """🎮 - 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 = await get_node_name()
+    if server_task is None:
+        server_task = asyncio.create_task(run_websocket_server())
+    await create_streamlit_interface()
 
 if __name__ == "__main__":
     asyncio.run(main())