Update app.py

app.py

@@ -19,9 +19,24 @@ logger = logging.getLogger("chat-node")
 
 # Dictionary to store active connections
 active_connections = {}
-# Dictionary to store message history for each chat room
+# Dictionary to store message history for each chat room (in-memory cache)
 chat_history = {}
 
+# Directory to store persistent chat history
+HISTORY_DIR = "chat_history"
+import os
+import shutil
+from pathlib import Path
+
+# Create history directory if it doesn't exist
+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")
+
 # Get node name from URL or command line
 def get_node_name():
     parser = argparse.ArgumentParser(description='Start a chat node with a specific name')
@@ -38,6 +53,82 @@ def get_node_name():
         
     return node_name, port
 
+def get_room_history_file(room_id):
+    """Get the filename for a room's history."""
+    return os.path.join(HISTORY_DIR, f"{room_id}.md")
+
+def load_room_history(room_id):
+    """Load chat history for a room from persistent storage."""
+    if room_id not in chat_history:
+        chat_history[room_id] = []
+        
+        # Try to load from file
+        history_file = get_room_history_file(room_id)
+        if os.path.exists(history_file):
+            try:
+                with open(history_file, 'r') as f:
+                    history_json = f.read()
+                    if history_json.strip():
+                        loaded_history = json.loads(history_json)
+                        chat_history[room_id] = loaded_history
+                        logger.info(f"Loaded {len(loaded_history)} messages from history for room {room_id}")
+            except Exception as e:
+                logger.error(f"Error loading history for room {room_id}: {e}")
+    
+    return chat_history[room_id]
+
+def save_room_history(room_id):
+    """Save chat history for a room to persistent storage."""
+    if room_id in chat_history and chat_history[room_id]:
+        history_file = get_room_history_file(room_id)
+        try:
+            with open(history_file, 'w') as f:
+                json.dump(chat_history[room_id], f)
+            logger.info(f"Saved {len(chat_history[room_id])} messages to history for room {room_id}")
+        except Exception as e:
+            logger.error(f"Error saving history for room {room_id}: {e}")
+
+def get_all_history_files():
+    """Get a list of all chat history files, sorted by modification time (newest first)."""
+    history_files = []
+    for file in os.listdir(HISTORY_DIR):
+        if file.endswith(".md") and file != "README.md":
+            file_path = os.path.join(HISTORY_DIR, file)
+            mod_time = os.path.getmtime(file_path)
+            room_id = file[:-3]  # Remove .md extension
+            history_files.append((room_id, file_path, mod_time))
+    
+    # Sort by modification time (newest first)
+    history_files.sort(key=lambda x: x[2], reverse=True)
+    return history_files
+
+async def clear_all_history():
+    """Clear all chat history for all rooms."""
+    global chat_history
+    
+    # Clear in-memory history
+    chat_history = {}
+    
+    # Delete all history files except README.md
+    for file in os.listdir(HISTORY_DIR):
+        if file.endswith(".md") and file != "README.md":
+            os.remove(os.path.join(HISTORY_DIR, file))
+    
+    # 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"
+
 async def websocket_handler(websocket, path):
     """Handle WebSocket connections."""
     try:
@@ -49,11 +140,13 @@ async def websocket_handler(websocket, path):
         client_id = str(uuid.uuid4())
         if room_id not in active_connections:
             active_connections[room_id] = {}
-            chat_history[room_id] = []
         
         active_connections[room_id][client_id] = websocket
         
-        # Send welcome message and chat history
+        # 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}'! Connected from node '{NODE_NAME}'",
@@ -64,7 +157,7 @@ async def websocket_handler(websocket, path):
         await websocket.send(json.dumps(welcome_msg))
         
         # Send chat history
-        for msg in chat_history[room_id]:
+        for msg in room_history:
             await websocket.send(json.dumps(msg))
         
         # Broadcast join notification
@@ -84,6 +177,11 @@ async def websocket_handler(websocket, path):
             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
+                
                 # Add metadata to the message
                 data["timestamp"] = datetime.now().isoformat()
                 data["sender_node"] = NODE_NAME
@@ -91,8 +189,11 @@ async def websocket_handler(websocket, path):
                 
                 # Store in history
                 chat_history[room_id].append(data)
-                if len(chat_history[room_id]) > 100:  # Limit history to 100 messages
-                    chat_history[room_id] = chat_history[room_id][-100:]
+                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_room_history(room_id)
                 
                 # Broadcast to all clients in the room
                 await broadcast_message(data, room_id)
@@ -124,10 +225,9 @@ async def websocket_handler(websocket, path):
             }
             await broadcast_message(leave_msg, room_id)
             
-            # Clean up empty rooms
+            # Clean up empty rooms (but keep history)
             if not active_connections[room_id]:
                 del active_connections[room_id]
-                # Optionally, you might want to keep the chat history
 
 async def broadcast_message(message, room_id):
     """Broadcast a message to all clients in a room."""
@@ -183,32 +283,79 @@ def join_room(room_id, chat_history_output):
     # Sanitize the room ID
     room_id = urllib.parse.quote(room_id.strip())
     
-    # Create the room if it doesn't exist
-    if room_id not in chat_history:
-        chat_history[room_id] = []
+    # Load room history from persistent storage
+    history = load_room_history(room_id)
     
     # Format existing messages
     formatted_history = []
-    for msg in chat_history[room_id]:
+    for msg in history:
         if msg.get("type") == "chat":
-            formatted_history.append(f"{msg.get('username', 'Anonymous')}: {msg.get('content', '')}")
+            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
 
+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..."
+
+def list_available_rooms():
+    """List all available chat rooms with their last activity time."""
+    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\n\n"
+    for room_id, file_path, mod_time in history_files:
+        last_activity = datetime.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M:%S")
+        room_list += f"- **{room_id}**: Last activity {last_activity}\n"
+    
+    return room_list
+
 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 gr.Row():
             room_id_input = gr.Textbox(label="Room ID", placeholder="Enter room ID")
             join_button = gr.Button("Join Room")
         
-        chat_history_output = gr.Textbox(label="Chat History", lines=15, max_lines=15)
+        # Chat area
+        chat_history_output = gr.Textbox(label="Chat History", lines=20, max_lines=20)
         
+        # Message controls
         with gr.Row():
             username_input = gr.Textbox(label="Username", placeholder="Enter your username", value="User")
             message_input = gr.Textbox(label="Message", placeholder="Type your message here")
@@ -218,6 +365,18 @@ def create_gradio_interface():
         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]
+        )
+        
         join_button.click(
             join_room,
             inputs=[room_id_input, chat_history_output],
@@ -247,6 +406,13 @@ def create_gradio_interface():
             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