diff --git a/rWeb_client.py b/rWeb_client.py
new file mode 100644
index 0000000..40a8e83
--- /dev/null
+++ b/rWeb_client.py
@@ -0,0 +1,1561 @@
+#!/usr/bin/env python3
+# lxmf_html_browser.py - Web-based LXMF HTML Browser
+
+import os
+import sys
+import json
+import time
+import threading
+from datetime import datetime
+from flask import Flask, render_template, request, jsonify
+from flask_socketio import SocketIO, emit
+
+# Check dependencies
+try:
+    import RNS
+    import LXMF
+except ImportError:
+    print("ERROR: Required packages not found!")
+    print("Install with: pip install rns lxmf flask flask-socketio")
+    sys.exit(1)
+
+class HTMLServerAnnounceHandler:
+    """Announce handler specifically for HTML servers (LXMF delivery destinations)"""
+    def __init__(self, browser):
+        self.aspect_filter = "lxmf.delivery"  # Only catch LXMF delivery announces
+        self.browser = browser
+    
+    def received_announce(self, destination_hash, announced_identity, app_data):
+        """Called when an LXMF delivery destination announces"""
+        try:
+            peer_hash_str = RNS.prettyhexrep(destination_hash)
+            
+            # Skip our own announces
+            if hasattr(self.browser, 'lxmf_destination'):
+                if destination_hash == self.browser.lxmf_destination.hash:
+                    return
+            
+            print(f"[ANNOUNCE] LXMF delivery destination: {peer_hash_str[:20]}...")
+            
+            if app_data:
+                # Use LXMF's helper to extract display name
+                from LXMF import display_name_from_app_data
+                display_name = display_name_from_app_data(app_data)
+                
+                if display_name:
+                    print(f"[ANNOUNCE]   Name: '{display_name}'")
+                    
+                    # Check for HTML marker
+                    if '[HTML]' in display_name or 'HTML' in display_name:
+                        print(f"\n{'='*60}")
+                        print(f"[ANNOUNCE] ✓✓✓ HTML SERVER FOUND ✓✓✓")
+                        print(f"[ANNOUNCE] Name: {display_name}")
+                        print(f"[ANNOUNCE] Hash: {peer_hash_str}")
+                        print(f"{'='*60}\n")
+                        self.browser._handle_discovery(peer_hash_str, display_name)
+        
+        except Exception as e:
+            print(f"[!] HTML announce handler error: {e}")
+            import traceback
+            traceback.print_exc()
+
+class LXMFHTMLBrowser:
+    def __init__(self, storage_path=None, identity_path=None):
+        # Terminal UI and paths setup
+        if storage_path is None:
+            storage_path = os.path.expanduser("~/.lxmf_html_browser")
+        
+        self.storage_path = storage_path
+        self.cache_path = os.path.join(storage_path, "cache")
+        self.html_cache_path = os.path.join(storage_path, "html_cache")
+        self.bookmarks_file = os.path.join(storage_path, "bookmarks.json")
+        self.history_file = os.path.join(storage_path, "history.json")
+        self.discovered_file = os.path.join(storage_path, "discovered_servers.json")
+        self.identity_file = identity_path or os.path.join(storage_path, "identity")
+        
+        # HTML field constants
+        self.FIELD_HTML_CONTENT = 10
+        self.FIELD_HTML_REQUEST = 11
+        
+        # Runtime
+        self.bookmarks = []
+        self.history = []
+        self.discovered_servers = {}
+        self.known_peers = set()
+        self.pending_requests = {}
+        self.socketio = None
+        self.running = True
+        
+        # Initialize storage and load data
+        self._init_storage()
+        self._load_data()
+        
+        # Initialize Reticulum FIRST
+        self._init_reticulum()
+        
+        # Register announce handler BEFORE LXMF is initialized
+        print("\n" + "="*60)
+        print("REGISTERING ANNOUNCE HANDLER (before LXMF)")
+        print("="*60 + "\n")
+        self._setup_announce_handler()
+        
+        # NOW initialize LXMF (this will register its own handlers after ours)
+        self._init_lxmf()
+        
+        # Don't need peer monitor
+        print("="*60)
+        print("Browser initialized - listening for announces")
+        print("="*60 + "\n")    
+
+    def _init_storage(self):
+        for path in [self.storage_path, self.cache_path, self.html_cache_path]:
+            if not os.path.exists(path):
+                os.makedirs(path)
+    
+    def _load_data(self):
+        if os.path.exists(self.bookmarks_file):
+            try:
+                with open(self.bookmarks_file, 'r') as f:
+                    self.bookmarks = json.load(f)
+            except:
+                self.bookmarks = []
+        
+        if os.path.exists(self.history_file):
+            try:
+                with open(self.history_file, 'r') as f:
+                    self.history = json.load(f)
+            except:
+                self.history = []
+        
+        if os.path.exists(self.discovered_file):
+            try:
+                with open(self.discovered_file, 'r') as f:
+                    self.discovered_servers = json.load(f)
+                    for server_hash in self.discovered_servers.keys():
+                        self.known_peers.add(server_hash)
+            except:
+                self.discovered_servers = {}
+    
+    def _save_data(self):
+        with open(self.bookmarks_file, 'w') as f:
+            json.dump(self.bookmarks, f, indent=2)
+        
+        if len(self.history) > 100:
+            self.history = self.history[-100:]
+        with open(self.history_file, 'w') as f:
+            json.dump(self.history, f, indent=2)
+        
+        with open(self.discovered_file, 'w') as f:
+            json.dump(self.discovered_servers, f, indent=2)
+    
+    def _init_reticulum(self):
+        """Initialize Reticulum"""
+        print("\n" + "="*60)
+        print("LXMF HTML Browser - Initializing Reticulum")
+        print("="*60 + "\n")
+        
+        try:
+            self.reticulum = RNS.Reticulum()
+            print("✓ Reticulum initialized")
+            print(f"  Version: {RNS.__version__ if hasattr(RNS, '__version__') else 'Unknown'}")
+            print(f"  Transport available: {hasattr(RNS, 'Transport')}")
+            print(f"  Can register handlers: {hasattr(RNS.Transport, 'register_announce_handler')}")
+        except Exception as e:
+            print(f"ERROR: Failed to initialize Reticulum: {e}")
+            sys.exit(1)
+        
+        # Load or create identity
+        if os.path.exists(self.identity_file):
+            self.identity = RNS.Identity.from_file(self.identity_file)
+            print(f"✓ Loaded identity")
+        else:
+            self.identity = RNS.Identity()
+            self.identity.to_file(self.identity_file)
+            print(f"✓ Created new identity")
+    
+    def _init_lxmf(self):
+        self.message_router = LXMF.LXMRouter(
+            identity=self.identity,
+            storagepath=self.storage_path
+        )
+        
+        self.lxmf_destination = self.message_router.register_delivery_identity(
+            self.identity,
+            display_name="LXMF HTML Browser"
+        )
+        
+        self.message_router.register_delivery_callback(self._handle_message)
+        
+        self.lxmf_destination.announce()
+        
+        self.client_hash = RNS.prettyhexrep(self.lxmf_destination.hash)
+        print(f"✓ LXMF initialized")
+        print(f"  Client: {self.client_hash}\n")
+
+    def _setup_announce_handler(self):
+        """Set up announce handler for HTML servers"""
+        print("Setting up HTML server announce handler...")
+        
+        # Create handler instance
+        self.html_announce_handler = HTMLServerAnnounceHandler(self)
+        
+        # Register with RNS Transport
+        RNS.Transport.register_announce_handler(self.html_announce_handler)
+        
+        print("✓ HTML server announce handler registered")
+        print(f"  Aspect filter: {self.html_announce_handler.aspect_filter}\n")
+
+    def _init_lxmf(self):
+        self.message_router = LXMF.LXMRouter(
+            identity=self.identity,
+            storagepath=self.storage_path
+        )
+        
+        self.lxmf_destination = self.message_router.register_delivery_identity(
+            self.identity,
+            display_name="LXMF HTML Browser"
+        )
+        
+        self.message_router.register_delivery_callback(self._handle_message)
+        
+        self.lxmf_destination.announce()
+        
+        self.client_hash = RNS.prettyhexrep(self.lxmf_destination.hash)
+        print(f"✓ LXMF initialized")
+        print(f"  Client: {self.client_hash}\n")
+        
+        # Process any discoveries that happened before LXMF was ready
+        if hasattr(self, '_pending_discoveries') and len(self._pending_discoveries) > 0:
+            print(f"[*] Processing {len(self._pending_discoveries)} pending discoveries...")
+            for discovery in self._pending_discoveries:
+                peer_hash_str, display_name = discovery
+                # Skip our own hash now that we know it
+                if peer_hash_str == self.client_hash:
+                    continue
+                self._handle_discovery(peer_hash_str, display_name)
+            self._pending_discoveries = []
+
+    def _start_peer_monitor(self):
+        """Just a simple status monitor"""
+        def monitor_loop():
+            print("✓ Status monitor started")
+            print("="*60 + "\n")
+            
+            while self.running:
+                time.sleep(10)
+        
+        threading.Thread(target=monitor_loop, daemon=True).start()
+
+    def _handle_discovery(self, peer_hash_str, display_name):
+        try:
+            server_name = display_name.replace('[HTML]', '').strip()
+            if not server_name:
+                server_name = "Unknown Server"
+            
+            # Check if already discovered
+            if peer_hash_str in self.known_peers:
+                # Just update last seen
+                if peer_hash_str in self.discovered_servers:
+                    self.discovered_servers[peer_hash_str]['last_seen'] = time.time()
+                    self._save_data()
+                return
+            
+            self.discovered_servers[peer_hash_str] = {
+                'name': server_name,
+                'pages': [],
+                'last_seen': time.time()
+            }
+            
+            self.known_peers.add(peer_hash_str)
+            self._save_data()
+            
+            print(f"\n{'='*60}")
+            print(f"[+] NEW HTML SERVER DISCOVERED!")
+            print(f"    Name: {server_name}")
+            print(f"    Hash: {peer_hash_str}")
+            print(f"{'='*60}\n")
+            
+            if self.socketio:
+                with app.app_context():
+                    self.socketio.emit('server_discovered', {
+                        'hash': peer_hash_str,
+                        'name': server_name,
+                        'timestamp': time.time()
+                    }, namespace='/')
+                    print(f"[+] UI notification sent")
+            
+            # REMOVED: Automatic page list request
+            # User can click on server to load pages when they want
+            
+        except Exception as e:
+            print(f"[!] Discovery error: {e}")
+            import traceback
+            traceback.print_exc()
+                
+    def _request_page_list(self, server_hash):
+        try:
+            if server_hash.startswith('<') and server_hash.endswith('>'):
+                server_hash = server_hash[1:-1]
+            
+            dest_hash = bytes.fromhex(server_hash.replace(':', ''))
+            
+            self.pending_requests[server_hash] = {'type': 'list', 'time': time.time()}
+            
+            self.lxmf_destination.announce()
+            time.sleep(0.3)
+            
+            dest_identity = RNS.Identity.recall(dest_hash)
+            if not dest_identity:
+                RNS.Transport.request_path(dest_hash)
+                time.sleep(2)
+                dest_identity = RNS.Identity.recall(dest_hash)
+            
+            if dest_identity:
+                dest = RNS.Destination(
+                    dest_identity,
+                    RNS.Destination.OUT,
+                    RNS.Destination.SINGLE,
+                    "lxmf", "delivery"
+                )
+                
+                lxmf_message = LXMF.LXMessage(
+                    dest,
+                    self.lxmf_destination,
+                    "list"
+                )
+                
+                self.message_router.handle_outbound(lxmf_message)
+                print(f"[>] Requested page list")
+        except Exception as e:
+            print(f"[!] Error requesting list: {e}")
+    
+    def _parse_page_list(self, text):
+        pages = []
+        try:
+            lines = text.split('\n')
+            for line in lines:
+                line = line.strip()
+                if line.startswith('[') and ']' in line:
+                    parts = line.split(']', 1)
+                    if len(parts) > 1:
+                        page_info = parts[1].strip()
+                        if '(' in page_info:
+                            page_name = page_info.split('(')[0].strip()
+                            if page_name:
+                                pages.append(page_name)
+        except:
+            pass
+        return pages
+    
+    def _save_html_file(self, html_content, filename, server_hash):
+        """Save HTML content with link interception script"""
+        # Inject JavaScript to intercept internal links
+        inject_script = f"""
+<script>
+// LXMF Browser - Link Interceptor
+(function() {{
+    const currentServer = '{server_hash}';
+    
+    document.addEventListener('DOMContentLoaded', function() {{
+        // Intercept all clicks on links
+        document.addEventListener('click', function(e) {{
+            let target = e.target;
+            
+            // Find the closest <a> tag
+            while (target && target.tagName !== 'A') {{
+                target = target.parentElement;
+            }}
+            
+            if (target && target.tagName === 'A') {{
+                const href = target.getAttribute('href');
+                
+                // Check if it's a relative link or .html file
+                if (href && (href.endsWith('.html') || !href.includes('://'))) {{
+                    e.preventDefault();
+                    
+                    // Extract page name
+                    let pageName = href;
+                    if (pageName.startsWith('./')) {{
+                        pageName = pageName.substring(2);
+                    }}
+                    if (pageName.startsWith('/')) {{
+                        pageName = pageName.substring(1);
+                    }}
+                    
+                    // Tell parent window to request this page from LXMF
+                    window.parent.postMessage({{
+                        type: 'lxmf_navigate',
+                        server: currentServer,
+                        page: pageName
+                    }}, '*');
+                }}
+            }}
+        }}, true);
+    }});
+}})();
+</script>
+"""
+        
+        # Inject before </head> or </body> or at end
+        if '</head>' in html_content:
+            html_content = html_content.replace('</head>', inject_script + '</head>')
+        elif '</body>' in html_content:
+            html_content = html_content.replace('</body>', inject_script + '</body>')
+        else:
+            html_content += inject_script
+        
+        filepath = os.path.join(self.html_cache_path, filename)
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        return filename
+
+    def _handle_message(self, message):
+        """Handle incoming LXMF messages"""
+        try:
+            server_hash = RNS.prettyhexrep(message.source_hash)
+            content = message.content.decode('utf-8') if isinstance(message.content, bytes) else message.content
+            
+            print(f"[<] Message from {server_hash[:20]}...")
+            
+            is_pending = server_hash in self.pending_requests
+            
+            # Handle page list response
+            if is_pending and self.pending_requests[server_hash].get('type') == 'list':
+                if "Available Pages" in content:
+                    pages = self._parse_page_list(content)
+                    
+                    print(f"[+] Received {len(pages)} pages")
+                    
+                    if server_hash in self.discovered_servers:
+                        self.discovered_servers[server_hash]['pages'] = pages
+                        self._save_data()
+                        
+                        if self.socketio:
+                            with app.app_context():
+                                self.socketio.emit('pages_updated', {
+                                    'hash': server_hash,
+                                    'pages': pages
+                                }, namespace='/')
+                    
+                    del self.pending_requests[server_hash]
+                    return
+            
+            # Check for fields
+            if hasattr(message, 'fields') and message.fields:
+                # Handle HTML content (for rendering in browser)
+                if self.FIELD_HTML_CONTENT in message.fields:
+                    html_content = message.fields[self.FIELD_HTML_CONTENT]
+                    
+                    page_name = "page.html"
+                    if content.startswith("Serving:"):
+                        page_name = content.replace("Serving:", "").strip()
+                    elif "Page Index" in content or "Available Pages" in content:
+                        page_name = "index.html"
+                    
+                    server_name = self.discovered_servers.get(server_hash, {}).get('name', 'Unknown Server')
+                    
+                    print(f"[+] Received HTML: {page_name} ({len(html_content)} bytes)")
+                    print(f"[DEBUG] server_hash: {server_hash}")
+                    print(f"[DEBUG] server_name: {server_name}")
+                    
+                    # Save HTML to file with link interception
+                    timestamp = int(time.time())
+                    filename = f"{timestamp}_{page_name}"
+                    saved_filename = self._save_html_file(html_content, filename, server_hash)
+                    
+                    # Save to history
+                    self.history.append({
+                        'server': server_hash,
+                        'server_name': server_name,
+                        'page': page_name,
+                        'timestamp': time.time()
+                    })
+                    self._save_data()
+                    
+                    # Send to web UI
+                    if self.socketio:
+                        with app.app_context():
+                            self.socketio.emit('html_received', {
+                                'server': server_hash,
+                                'server_name': server_name,
+                                'page': page_name,
+                                'filename': saved_filename,
+                                'timestamp': time.time()
+                            }, namespace='/')
+                            print(f"[+] WebSocket event emitted")
+                    
+                    if is_pending and server_hash in self.pending_requests:
+                        del self.pending_requests[server_hash]
+                    
+                    return
+                
+                # Handle file attachments (for downloads)
+                if 2 in message.fields:  # FIELD_FILE_ATTACHMENTS
+                    file_attachments = message.fields[2]
+                    
+                    print(f"[+] Received {len(file_attachments)} file attachment(s)")
+                    
+                    server_name = self.discovered_servers.get(server_hash, {}).get('name', 'Unknown Server')
+                    
+                    # Process each file attachment
+                    for attachment in file_attachments:
+                        # Handle both list and tuple formats
+                        if (isinstance(attachment, (list, tuple)) and len(attachment) >= 2):
+                            filename = attachment[0]
+                            file_data = attachment[1]
+                            
+                            # Save file to cache
+                            file_path = os.path.join(self.cache_path, filename)
+                            with open(file_path, 'wb') as f:
+                                f.write(file_data)
+                            
+                            file_size = len(file_data)
+                            size_str = f"{file_size:,} bytes" if file_size < 1024 else f"{file_size/1024:.1f} KB"
+                            if file_size >= 1024*1024:
+                                size_str = f"{file_size/(1024*1024):.2f} MB"
+                            
+                            print(f"[+] Saved file: {filename} ({size_str})")
+                            
+                            # Save to history
+                            self.history.append({
+                                'server': server_hash,
+                                'server_name': server_name,
+                                'page': filename,
+                                'timestamp': time.time(),
+                                'type': 'file'
+                            })
+                            self._save_data()
+                            
+                            # Send to web UI with download link
+                            if self.socketio:
+                                with app.app_context():
+                                    self.socketio.emit('file_received', {
+                                        'server': server_hash,
+                                        'server_name': server_name,
+                                        'filename': filename,
+                                        'size': size_str,
+                                        'timestamp': time.time()
+                                    }, namespace='/')
+                                    print(f"[+] file_received event emitted")
+                    
+                    if is_pending and server_hash in self.pending_requests:
+                        del self.pending_requests[server_hash]
+                    
+                    return
+            
+            print(f"[+] Text message: {content[:50]}...")
+            
+        except Exception as e:
+            print(f"[!] Message handler error: {e}")
+            import traceback
+            traceback.print_exc()
+    
+    def request_page(self, server_hash, page_name):
+        try:
+            if server_hash.startswith('<') and server_hash.endswith('>'):
+                server_hash = server_hash[1:-1]
+            
+            if server_hash.startswith('lxmf://'):
+                server_hash = server_hash[7:]
+            
+            if '/' in server_hash:
+                parts = server_hash.split('/', 1)
+                server_hash = parts[0]
+                if len(parts) > 1 and not page_name:
+                    page_name = parts[1]
+            
+            if not page_name:
+                page_name = "index"
+            
+            print(f"[>] Requesting {page_name} from {server_hash[:20]}...")
+            
+            dest_hash = bytes.fromhex(server_hash.replace(':', ''))
+            
+            self.pending_requests[server_hash] = {'type': 'page', 'page': page_name, 'time': time.time()}
+            
+            self.lxmf_destination.announce()
+            time.sleep(0.3)
+            
+            dest_identity = RNS.Identity.recall(dest_hash)
+            if not dest_identity:
+                print(f"[!] Requesting path...")
+                RNS.Transport.request_path(dest_hash)
+                time.sleep(2)
+                dest_identity = RNS.Identity.recall(dest_hash)
+            
+            if dest_identity:
+                dest = RNS.Destination(
+                    dest_identity,
+                    RNS.Destination.OUT,
+                    RNS.Destination.SINGLE,
+                    "lxmf", "delivery"
+                )
+                
+                fields = {self.FIELD_HTML_REQUEST: page_name}
+                
+                lxmf_message = LXMF.LXMessage(
+                    dest,
+                    self.lxmf_destination,
+                    f"GET:{page_name}",
+                    title="",
+                    fields=fields
+                )
+                
+                self.message_router.handle_outbound(lxmf_message)
+                print(f"[+] Request sent")
+                return True
+            else:
+                print(f"[!] Could not establish path")
+                return False
+            
+        except Exception as e:
+            print(f"[!] Request error: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
+# Flask app
+app = Flask(__name__)
+app.config['SECRET_KEY'] = 'lxmf-html-browser-secret'
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')
+
+browser = None
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/html/<filename>')
+def serve_html(filename):
+    """Serve cached HTML files"""
+    from flask import send_from_directory
+    return send_from_directory(browser.html_cache_path, filename)
+
+@app.route('/api/servers')
+def get_servers():
+    servers = []
+    for hash, info in browser.discovered_servers.items():
+        servers.append({
+            'hash': hash,
+            'name': info['name'],
+            'pages': info.get('pages', []),
+            'last_seen': info['last_seen']
+        })
+    return jsonify(servers)
+
+@app.route('/api/bookmarks')
+def get_bookmarks():
+    return jsonify(browser.bookmarks)
+
+@app.route('/api/bookmark/add', methods=['POST'])
+def add_bookmark():
+    data = request.json
+    bookmark = {
+        'name': data['name'],
+        'hash': data['hash'],
+        'added': time.time()
+    }
+    browser.bookmarks.append(bookmark)
+    browser._save_data()
+    return jsonify({'success': True})
+
+@app.route('/api/bookmark/remove', methods=['POST'])
+def remove_bookmark():
+    data = request.json
+    browser.bookmarks = [b for b in browser.bookmarks if b['hash'] != data['hash']]
+    browser._save_data()
+    return jsonify({'success': True})
+
+@app.route('/api/history')
+def get_history():
+    return jsonify(browser.history[-50:])
+
+@app.route('/api/request_page', methods=['POST'])
+def request_page():
+    data = request.json
+    success = browser.request_page(data.get('server', ''), data.get('page', 'index'))
+    return jsonify({'success': success})
+
+@app.route('/api/refresh_server', methods=['POST'])
+def refresh_server():
+    data = request.json
+    browser._request_page_list(data['hash'])
+    return jsonify({'success': True})
+
+@app.route('/download/<filename>')
+def download_file(filename):
+    """Serve downloaded files"""
+    from flask import send_from_directory
+    print(f"[*] Download requested: {filename}")
+    print(f"[*] Cache path: {browser.cache_path}")
+    
+    filepath = os.path.join(browser.cache_path, filename)
+    print(f"[*] Full path: {filepath}")
+    print(f"[*] File exists: {os.path.exists(filepath)}")
+    
+    return send_from_directory(browser.cache_path, filename, as_attachment=True)
+
+@app.route('/api/history/clear', methods=['POST'])
+def clear_history():
+    browser.history = []
+    browser._save_data()
+    return jsonify({'success': True})
+
+@app.route('/api/server/remove', methods=['POST'])
+def remove_server():
+    data = request.json
+    server_hash = data['hash']
+    
+    if server_hash in browser.discovered_servers:
+        browser.discovered_servers.pop(server_hash)
+    
+    if server_hash in browser.known_peers:
+        browser.known_peers.remove(server_hash)
+    
+    browser._save_data()
+    return jsonify({'success': True})
+
+@socketio.on('connect')
+def handle_connect():
+    print("[+] Web UI connected")
+    emit('connected', {'status': 'ready'})
+
+@socketio.on('disconnect')
+def handle_disconnect():
+    print("[-] Web UI disconnected")
+
+# Modern Blue/Black UI Template with iframe isolation AND link interception
+INDEX_HTML = """<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>LXMF Browser</title>
+    <script src="https://cdn.socket.io/4.5.4/socket.io.min.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+            background: #0a0e27;
+            color: #e0e6ed;
+            height: 100vh;
+            overflow: hidden;
+        }
+        
+        .container {
+            display: flex;
+            height: 100vh;
+        }
+        
+        .sidebar {
+            width: 320px;
+            background: #0d1117;
+            border-right: 1px solid #1f2937;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .header {
+            padding: 24px;
+            background: linear-gradient(135deg, #1e40af 0%, #3b82f6 100%);
+            color: white;
+        }
+        
+        .header h1 {
+            font-size: 1.5em;
+            font-weight: 600;
+        }
+        
+        .tabs {
+            display: flex;
+            background: #161b22;
+            border-bottom: 1px solid #1f2937;
+        }
+        
+        .tab {
+            flex: 1;
+            padding: 14px;
+            background: transparent;
+            border: none;
+            color: #8b949e;
+            cursor: pointer;
+            transition: all 0.2s;
+            font-size: 0.9em;
+            font-weight: 500;
+        }
+        
+        .tab:hover {
+            background: #1f2937;
+            color: #e0e6ed;
+        }
+        
+        .tab.active {
+            background: #0d1117;
+            color: #3b82f6;
+            border-bottom: 2px solid #3b82f6;
+        }
+        
+        .tab-content {
+            flex: 1;
+            overflow-y: auto;
+            padding: 16px;
+        }
+        
+        .server-item {
+            background: #161b22;
+            margin: 12px 0;
+            padding: 16px;
+            border-radius: 8px;
+            border-left: 3px solid #3b82f6;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        
+        .server-item:hover {
+            background: #1f2937;
+            transform: translateX(4px);
+        }
+        
+        .server-name {
+            font-size: 1.1em;
+            font-weight: 600;
+            color: #e0e6ed;
+            margin-bottom: 8px;
+        }
+        
+        .server-info {
+            font-size: 0.85em;
+            color: #8b949e;
+            word-break: break-all;
+        }
+        
+        .page-list {
+            margin-top: 12px;
+            padding-left: 12px;
+        }
+        
+        .page-link {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            color: #3b82f6;
+            padding: 8px;
+            cursor: pointer;
+            transition: all 0.2s;
+            border-radius: 4px;
+            font-size: 0.9em;
+        }
+        
+        .page-link:hover {
+            background: rgba(59, 130, 246, 0.1);
+            padding-left: 12px;
+        }
+        
+        .main-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .address-bar {
+            background: #161b22;
+            padding: 16px;
+            display: flex;
+            gap: 12px;
+            align-items: center;
+            border-bottom: 1px solid #1f2937;
+        }
+        
+        .address-bar input {
+            flex: 1;
+            padding: 12px 16px;
+            background: #0d1117;
+            border: 1px solid #1f2937;
+            color: #e0e6ed;
+            border-radius: 6px;
+            font-size: 0.95em;
+            transition: all 0.2s;
+        }
+        
+        .address-bar input:focus {
+            outline: none;
+            border-color: #3b82f6;
+            box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
+        }
+        
+        .btn {
+            padding: 10px 20px;
+            background: #3b82f6;
+            border: none;
+            color: white;
+            cursor: pointer;
+            border-radius: 6px;
+            transition: all 0.2s;
+            font-size: 0.9em;
+            font-weight: 500;
+        }
+        
+        .btn:hover {
+            background: #2563eb;
+            transform: translateY(-1px);
+            box-shadow: 0 4px 12px rgba(59, 130, 246, 0.4);
+        }
+        
+        .btn-secondary {
+            background: #1f2937;
+        }
+        
+        .btn-secondary:hover {
+            background: #374151;
+        }
+        
+        .content-frame {
+            flex: 1;
+            background: white;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .content-frame iframe {
+            width: 100%;
+            height: 100%;
+            border: none;
+            display: block;
+        }
+        
+        .welcome-content {
+            padding: 32px;
+            max-width: 600px;
+            margin: 0 auto;
+        }
+        
+        .welcome-content h2 {
+            color: #0a0e27;
+            font-size: 2em;
+            margin-bottom: 16px;
+        }
+        
+        .welcome-content p {
+            color: #6b7280;
+            line-height: 1.6;
+            margin: 12px 0;
+        }
+        
+        .code {
+            background: #f3f4f6;
+            padding: 12px;
+            border-radius: 6px;
+            font-family: monospace;
+            margin: 16px 0;
+            color: #1f2937;
+        }
+        
+        .status {
+            background: #161b22;
+            color: #8b949e;
+            padding: 12px 20px;
+            border-top: 1px solid #1f2937;
+            font-size: 0.85em;
+        }
+        
+        .notification {
+            position: fixed;
+            top: 24px;
+            right: 24px;
+            background: white;
+            color: #0a0e27;
+            padding: 16px 24px;
+            border-radius: 8px;
+            box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
+            animation: slideIn 0.3s ease-out;
+            z-index: 1000;
+            border-left: 4px solid #3b82f6;
+        }
+        
+        @keyframes slideIn {
+            from {
+                transform: translateX(400px);
+                opacity: 0;
+            }
+            to {
+                transform: translateX(0);
+                opacity: 1;
+            }
+        }
+        
+        .loading {
+            text-align: center;
+            padding: 60px 20px;
+            color: #8b949e;
+        }
+        
+        .spinner {
+            display: inline-block;
+            width: 48px;
+            height: 48px;
+            border: 4px solid #1f2937;
+            border-top-color: #3b82f6;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin-bottom: 16px;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        ::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+        
+        ::-webkit-scrollbar-track {
+            background: #0d1117;
+        }
+        
+        ::-webkit-scrollbar-thumb {
+            background: #1f2937;
+            border-radius: 4px;
+        }
+        
+        ::-webkit-scrollbar-thumb:hover {
+            background: #374151;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="sidebar">
+            <div class="header">
+                <h1>🌐 LXMF Browser</h1>
+            </div>
+            
+            <div class="tabs">
+                <button class="tab active" onclick="switchTab('servers')">Servers</button>
+                <button class="tab" onclick="switchTab('bookmarks')">Bookmarks</button>
+                <button class="tab" onclick="switchTab('history')">History</button>
+            </div>
+            
+            <div class="tab-content" id="servers-content">
+                <div class="loading">
+                    <div class="spinner"></div>
+                    <div>Listening for announces...</div>
+                </div>
+            </div>
+            
+            <div class="tab-content" id="bookmarks-content" style="display:none;">
+                <div class="loading">No bookmarks yet</div>
+            </div>
+            
+            <div class="tab-content" id="history-content" style="display:none;">
+                <div class="loading">No history yet</div>
+            </div>
+        </div>
+        
+        <div class="main-content">
+            <div class="address-bar">
+                <input type="text" id="address" placeholder="Enter server hash or lxmf://<hash>/<page>">
+                <button class="btn" onclick="navigate()">Go</button>
+                <button class="btn btn-secondary" onclick="refresh()">Refresh</button>
+                <button class="btn btn-secondary" onclick="addBookmark()">★ Bookmark</button>
+            </div>
+            
+            <div class="content-frame" id="content">
+                <div class="welcome-content">
+                    <h2>Welcome to LXMF Browser</h2>
+                    <p>Browse decentralized HTML content over the Reticulum network.</p>
+                    <p><strong>To get started:</strong></p>
+                    <ul style="margin-left: 20px; line-height: 2;">
+                        <li>Enter a server hash in the address bar above</li>
+                        <li>Or wait for HTML servers to announce on the network</li>
+                        <li>Discovered servers will appear in the sidebar</li>
+                    </ul>
+                    <div class="code">
+                        Format: lxmf://&lt;server_hash&gt;/&lt;page&gt;<br>
+                        Example: lxmf://a1b2c3.../index.html
+                    </div>
+                </div>
+            </div>
+            
+            <div class="status" id="status">
+                Ready • Listening for announces
+            </div>
+        </div>
+    </div>
+<script>
+    const socket = io();
+    let currentServer = null;
+    let currentPage = null;
+    let servers = {};
+    let bookmarks = [];
+    let history = [];
+    
+    // Listen for messages from iframe (link clicks)
+    window.addEventListener('message', function(event) {
+        if (event.data.type === 'lxmf_navigate') {
+            console.log('Link clicked in page:', event.data.page);
+            requestPage(event.data.server, event.data.page);
+        }
+    });
+    
+    socket.on('connect', () => {
+        console.log('✓ Connected to server');
+        loadServers();
+        loadBookmarks();
+        loadHistory();
+    });
+    
+    socket.on('connected', (data) => {
+        console.log('✓ Connection confirmed:', data);
+    });
+    
+    socket.on('server_discovered', (data) => {
+        console.log('✓ Server discovered:', data);
+        showNotification(`🎉 New server: ${data.name}`);
+        loadServers();
+    });
+    
+    socket.on('pages_updated', (data) => {
+        console.log('✓ Pages updated:', data);
+        loadServers();
+    });
+    
+    socket.on('html_received', (data) => {
+        console.log('✓ HTML received:', data.page, 'file:', data.filename);
+        displayHTML(data.filename, data.server, data.server_name, data.page);
+        loadHistory();
+    });
+    
+    socket.on('file_received', (data) => {
+        console.log('✓ File received event:', data);
+        console.log('Download URL:', `/download/${data.filename}`);
+        
+        // Trigger download
+        const downloadLink = document.createElement('a');
+        downloadLink.href = `/download/${data.filename}`;
+        downloadLink.download = data.filename;
+        downloadLink.style.display = 'none';
+        document.body.appendChild(downloadLink);
+        
+        console.log('Triggering download click...');
+        downloadLink.click();
+        
+        setTimeout(() => {
+            document.body.removeChild(downloadLink);
+        }, 100);
+        
+        showNotification(`✓ Downloaded: ${data.filename}`);
+        document.getElementById('status').textContent = `Downloaded: ${data.filename}`;
+        loadHistory();
+    });
+    
+    async function loadServers() {
+        const response = await fetch('/api/servers');
+        const data = await response.json();
+        servers = {};
+        data.forEach(s => servers[s.hash] = s);
+        renderServers();
+        renderBookmarks(); // Re-render bookmarks when servers update
+    }
+    
+    async function loadBookmarks() {
+        const response = await fetch('/api/bookmarks');
+        bookmarks = await response.json();
+        renderBookmarks();
+    }
+    
+    async function loadHistory() {
+        const response = await fetch('/api/history');
+        history = await response.json();
+        renderHistory();
+    }
+
+    function renderServers() {
+        const container = document.getElementById('servers-content');
+        const serverList = Object.values(servers);
+        
+        if (serverList.length === 0) {
+            container.innerHTML = '<div class="loading"><div class="spinner"></div><div>No servers discovered yet</div></div>';
+            return;
+        }
+        
+        container.innerHTML = serverList.map(server => {
+            // The hash is the key in the servers dict, not a property
+            const serverHash = Object.keys(servers).find(key => servers[key] === server);
+            
+            // Escape HTML characters in the hash
+            const escapedHash = serverHash
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+            
+            return `
+            <div class="server-item" style="position: relative; cursor: pointer; padding-bottom: 10px;" onclick="requestPage('${serverHash.replace(/[<>]/g, '')}', 'index')">
+                <div style="display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 5px;">
+                    <div class="server-name" style="flex: 1; padding-right: 10px;">${server.name}</div>
+                    <button onclick="event.stopPropagation(); removeServer('${serverHash.replace(/[<>]/g, '')}')" 
+                            style="flex-shrink: 0;
+                                background: #dc2626; 
+                                color: white; 
+                                border: none; 
+                                border-radius: 4px; 
+                                padding: 6px 10px; 
+                                cursor: pointer; 
+                                font-size: 0.75em;
+                                font-weight: 500;
+                                transition: all 0.2s;"
+                            onmouseover="this.style.background='#b91c1c'"
+                            onmouseout="this.style.background='#dc2626'">
+                        🗑️
+                    </button>
+                </div>
+                <div class="server-info" style="font-size: 0.75em; word-break: break-all; line-height: 1.5; color: #8b949e; margin-top: 8px;">
+                    <div style="margin-bottom: 4px;">
+                        <strong style="color: #6b7280;">Address:</strong><br>
+                        <span style="font-family: 'Courier New', monospace; font-size: 0.95em;">${escapedHash}</span>
+                    </div>
+                    <div style="color: #6b7280;">
+                        <strong>Last seen:</strong> ${new Date(server.last_seen * 1000).toLocaleString()}
+                    </div>
+                </div>
+                ${server.pages && server.pages.length > 0 ? `
+                    <div class="page-list" style="margin-top: 12px;">
+                        ${server.pages.slice(0, 8).map(page => `
+                            <div class="page-link" onclick="event.stopPropagation(); requestPage('${serverHash.replace(/[<>]/g, '')}', '${page}')">
+                                📄 ${page}
+                            </div>
+                        `).join('')}
+                        ${server.pages.length > 8 ? `<div style="color: #8b949e; font-size: 0.85em; padding: 8px 5px;">...and ${server.pages.length - 8} more</div>` : ''}
+                    </div>
+                ` : ''}
+            </div>
+        `;
+        }).join('');
+    }
+
+    async function removeServer(serverHash) {
+        if (confirm('Remove this server from discovered list?')) {
+            await fetch('/api/server/remove', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({hash: `<${serverHash}>`})
+            });
+            loadServers();
+            showNotification('✓ Server removed');
+        }
+    }    
+
+    function renderBookmarks() {
+        const container = document.getElementById('bookmarks-content');
+        
+        if (bookmarks.length === 0) {
+            container.innerHTML = '<div class="loading">No bookmarks yet</div>';
+            return;
+        }
+        
+        container.innerHTML = bookmarks.map(bm => {
+            const server = servers[bm.hash];
+            const serverName = server ? server.name : bm.name;
+            
+            // Truncate long server names
+            const displayName = serverName.length > 30 ? serverName.substring(0, 27) + '...' : serverName;
+            
+            return `
+                <div class="server-item" style="position: relative; cursor: pointer; padding-bottom: 10px;" onclick="requestPage('${bm.hash}', 'index')">
+                    <div style="display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 5px;">
+                        <div class="server-name" style="flex: 1; padding-right: 10px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;">${displayName}</div>
+                        <button onclick="event.stopPropagation(); removeBookmark('${bm.hash}')" 
+                                style="flex-shrink: 0;
+                                    background: #dc2626; 
+                                    color: white; 
+                                    border: none; 
+                                    border-radius: 4px; 
+                                    padding: 6px 10px; 
+                                    cursor: pointer; 
+                                    font-size: 0.75em;
+                                    font-weight: 500;
+                                    transition: all 0.2s;"
+                                onmouseover="this.style.background='#b91c1c'"
+                                onmouseout="this.style.background='#dc2626'">
+                            🗑️
+                        </button>
+                    </div>
+                    ${server && server.pages && server.pages.length > 0 ? `
+                        <div class="page-list" style="margin-top: 8px;">
+                            ${server.pages.slice(0, 5).map(page => `
+                                <div class="page-link" onclick="event.stopPropagation(); requestPage('${bm.hash}', '${page}')">
+                                    📄 ${page}
+                                </div>
+                            `).join('')}
+                            ${server.pages.length > 5 ? `<div style="color: #8b949e; font-size: 0.85em; padding: 8px 5px;">...and ${server.pages.length - 5} more</div>` : ''}
+                        </div>
+                    ` : ''}
+                </div>
+            `;
+        }).join('');
+    }        
+
+    function renderHistory() {
+        const container = document.getElementById('history-content');
+        
+        if (history.length === 0) {
+            container.innerHTML = '<div class="loading">No history yet</div>';
+            return;
+        }
+        
+        const reversed = [...history].reverse();
+        
+        let html = `
+            <div style="padding: 12px;">
+                <button onclick="clearHistory()" 
+                        style="width: 100%; 
+                            padding: 12px; 
+                            background: #dc2626; 
+                            color: white; 
+                            border: none; 
+                            border-radius: 6px; 
+                            cursor: pointer; 
+                            font-size: 0.9em;
+                            font-weight: 500;
+                            transition: all 0.2s;"
+                        onmouseover="this.style.background='#b91c1c'"
+                        onmouseout="this.style.background='#dc2626'">
+                    🗑️ Clear History
+                </button>
+            </div>
+        `;
+        
+        html += reversed.map(h => {
+            const serverHash = h.server || '';
+            const fullUrl = serverHash ? `lxmf://${serverHash}/${h.page}` : `${h.page}`;
+            
+            // Escape HTML to prevent < > from being interpreted as tags
+            const escapedUrl = fullUrl
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&#039;');
+            
+            return `
+                <div class="server-item" onclick="requestPage('${serverHash.replace(/[<>]/g, '')}', '${h.page}')" style="cursor: pointer;">
+                    <div class="server-name" style="margin-bottom: 8px;">${h.server_name || 'Unknown Server'}</div>
+                    <div class="server-info" style="font-size: 0.72em; line-height: 1.5;">
+                        <div style="color: #0ff; word-break: break-all; margin-bottom: 6px; font-family: 'Courier New', monospace;">
+                            ${escapedUrl}
+                        </div>
+                        <div style="color: #8b949e; font-size: 0.95em;">
+                            ${new Date(h.timestamp * 1000).toLocaleString()}
+                        </div>
+                    </div>
+                </div>
+            `;
+        }).join('');
+        
+        container.innerHTML = html;
+    }        
+    
+    async function navigate() {
+        const address = document.getElementById('address').value.trim();
+        if (!address) return;
+        
+        let serverHash = address;
+        let pageName = 'index';
+        
+        if (address.startsWith('lxmf://')) {
+            serverHash = address.substring(7);
+        }
+        
+        if (serverHash.includes('/')) {
+            const parts = serverHash.split('/');
+            serverHash = parts[0];
+            pageName = parts[1] || 'index';
+        }
+        
+        requestPage(serverHash, pageName);
+    }
+    
+    async function requestPage(serverHash, pageName) {
+        currentServer = serverHash;
+        currentPage = pageName;
+        
+        console.log('Requesting:', serverHash, pageName);
+        
+        document.getElementById('address').value = `lxmf://${serverHash}/${pageName}`;
+        
+        // Check if this is an HTML file or other file type
+        const isHTML = pageName.toLowerCase().endsWith('.html') || 
+                       pageName.toLowerCase().endsWith('.htm') ||
+                       pageName.toLowerCase() === 'index' ||
+                       pageName.toLowerCase() === 'list';
+        
+        if (isHTML) {
+            document.getElementById('status').textContent = `Loading ${pageName}...`;
+            document.getElementById('content').innerHTML = '<div class="loading"><div class="spinner"></div><div>Loading page...</div></div>';
+        } else {
+            document.getElementById('status').textContent = `Requesting ${pageName}...`;
+            showNotification(`📥 Requesting ${pageName}...`);
+        }
+        
+        await fetch('/api/request_page', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({server: serverHash, page: pageName})
+        });
+    }
+    
+    async function refreshServer(serverHash) {
+        await fetch('/api/refresh_server', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({hash: serverHash})
+        });
+        showNotification('Refreshing...');
+    }
+    
+    function displayHTML(filename, serverHash, serverName, pageName) {
+        console.log('Displaying HTML in iframe:', filename);
+        
+        // Create iframe to isolate HTML content
+        const iframe = document.createElement('iframe');
+        iframe.src = `/html/${filename}`;
+        iframe.sandbox = 'allow-scripts allow-same-origin';
+        
+        document.getElementById('content').innerHTML = '';
+        document.getElementById('content').appendChild(iframe);
+        document.getElementById('status').textContent = `${serverName} / ${pageName}`;
+    }
+    
+    async function addBookmark() {
+        if (!currentServer) {
+            alert('No page loaded');
+            return;
+        }
+        
+        const server = servers[currentServer];
+        const defaultName = server ? server.name : 'Server';
+        
+        const name = prompt('Bookmark name:', defaultName);
+        if (name) {
+            await fetch('/api/bookmark/add', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({name, hash: currentServer})
+            });
+            loadBookmarks();
+            showNotification('✓ Bookmark added!');
+        }
+    }
+    
+    async function removeBookmark(serverHash) {
+        if (confirm('Remove this bookmark?')) {
+            await fetch('/api/bookmark/remove', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({hash: serverHash})
+            });
+            loadBookmarks();
+            showNotification('✓ Bookmark removed');
+        }
+    }
+    
+    async function clearHistory() {
+        if (confirm('Clear all browsing history?')) {
+            await fetch('/api/history/clear', {
+                method: 'POST'
+            });
+            loadHistory();
+            showNotification('✓ History cleared');
+        }
+    }
+    
+    function refresh() {
+        if (currentServer && currentPage) {
+            requestPage(currentServer, currentPage);
+        }
+    }
+    
+    function switchTab(tab) {
+        document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+        document.querySelectorAll('.tab-content').forEach(c => c.style.display = 'none');
+        
+        event.target.classList.add('active');
+        document.getElementById(`${tab}-content`).style.display = 'block';
+    }
+    
+    function showNotification(message) {
+        const notif = document.createElement('div');
+        notif.className = 'notification';
+        notif.textContent = message;
+        document.body.appendChild(notif);
+        
+        setTimeout(() => notif.remove(), 3000);
+    }
+    
+    document.getElementById('address').addEventListener('keypress', (e) => {
+        if (e.key === 'Enter') {
+            navigate();
+        }
+    });
+</script>
+</body>
+</html>
+"""
+
+def create_templates():
+    templates_dir = "templates"
+    if not os.path.exists(templates_dir):
+        os.makedirs(templates_dir)
+    
+    with open(os.path.join(templates_dir, "index.html"), 'w', encoding='utf-8') as f:
+        f.write(INDEX_HTML)
+
+# Add this in main() after browser is created:
+def main():
+    global browser
+    
+    print("="*60)
+    print("LXMF HTML Browser")
+    print("="*60)
+    
+    create_templates()
+    
+    browser = LXMFHTMLBrowser()
+    browser.socketio = socketio
+    
+    # Debug: Check if any servers exist
+    print("\n[DEBUG] Discovered servers at startup:")
+    if browser.discovered_servers:
+        for server_hash, server_info in browser.discovered_servers.items():
+            print(f"  - {server_info['name']}: {server_hash[:24]}...")
+    else:
+        print("  (none)")
+    
+    # TEMPORARY: Manually add your server for testing
+    # Replace this hash with your actual server hash from the server terminal
+    #test_server_hash = "<d4a08cf31603586d8657cd92cca71d58>"  # YOUR ACTUAL SERVER HASH
+    #if test_server_hash not in browser.discovered_servers:
+    #    print(f"\n[DEBUG] Adding test server manually: {test_server_hash}")
+    #    browser.discovered_servers[test_server_hash] = {
+    #        'name': 'Test HTML Server',
+    #        'pages': [],
+    #        'last_seen': time.time()
+    #    }
+    #    browser.known_peers.add(test_server_hash)
+    #    browser._save_data()
+    #    print("[DEBUG] Test server added")
+    
+    print("="*60)
+    print("Starting web server...")
+    print("="*60)
+    print("\n🌐 Open browser: http://localhost:5080\n")
+    
+    socketio.run(app, host='0.0.0.0', port=5080, debug=False, allow_unsafe_werkzeug=True)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/rWeb_server.py b/rWeb_server.py
new file mode 100644
index 0000000..0c56adf
--- /dev/null
+++ b/rWeb_server.py
@@ -0,0 +1,1756 @@
+#!/usr/bin/env python3
+# lxmf_html_server.py - Standalone LXMF HTML Server (Enhanced with Multi-File Support)
+
+import os
+import sys
+import json
+import time
+import argparse
+import threading
+import platform
+import base64
+import mimetypes
+from datetime import datetime
+
+# Cross-platform terminal handling
+if platform.system() == 'Windows':
+    try:
+        import colorama
+        colorama.init()
+    except ImportError:
+        pass
+
+# Check dependencies
+try:
+    import RNS
+    import LXMF
+except ImportError:
+    print("ERROR: Required packages not found!")
+    print("Install with: pip install rns lxmf")
+    sys.exit(1)
+
+class TerminalUI:
+    """Cross-platform terminal UI handler"""
+    
+    def __init__(self):
+        self.is_windows = platform.system() == 'Windows'
+        self.is_termux = 'com.termux' in os.environ.get('PREFIX', '')
+        self.supports_unicode = self._check_unicode_support()
+        
+    def _check_unicode_support(self):
+        """Check if terminal supports Unicode"""
+        try:
+            if self.is_windows:
+                # Windows 10+ usually supports Unicode
+                return sys.version_info >= (3, 6)
+            return True
+        except:
+            return False
+    
+    def icon(self, name):
+        """Get appropriate icon for terminal"""
+        if not self.supports_unicode:
+            # ASCII fallback
+            icons = {
+                'server': '[S]',
+                'online': '[*]',
+                'offline': '[ ]',
+                'page': '[-]',
+                'request': '[<]',
+                'response': '[>]',
+                'error': '[X]',
+                'info': '[i]',
+                'success': '[+]',
+                'warning': '[!]',
+                'network': '[N]',
+                'interface': '[I]',
+                'path': '[P]',
+                'time': '[T]',
+                'stats': '[=]',
+            }
+        else:
+            # Unicode icons
+            icons = {
+                'server': '🖥️ ',
+                'online': '🟢',
+                'offline': '⚫',
+                'page': '📄',
+                'request': '📨',
+                'response': '📤',
+                'error': '❌',
+                'info': 'ℹ️ ',
+                'success': '✅',
+                'warning': '⚠️ ',
+                'network': '🌐',
+                'interface': '🔌',
+                'path': '🛤️ ',
+                'time': '🕐',
+                'stats': '📊',
+            }
+        
+        return icons.get(name, '')
+    
+    def print_header(self, text, width=60):
+        """Print formatted header"""
+        print("\n" + "="*width)
+        print(f"{self.icon('server')} {text}")
+        print("="*width + "\n")
+    
+    def print_status(self, status, message):
+        """Print status message with icon"""
+        icon = self.icon(status)
+        timestamp = datetime.now().strftime('%H:%M:%S')
+        print(f"[{timestamp}] {icon} {message}")
+    
+    def clear_line(self):
+        """Clear current line"""
+        if not self.is_windows:
+            sys.stdout.write('\r\033[K')
+        else:
+            sys.stdout.write('\r' + ' '*80 + '\r')
+        sys.stdout.flush()
+
+class LXMFHTMLServer:
+    def __init__(self, storage_path=None, identity_path=None):
+        # Terminal UI
+        self.ui = TerminalUI()
+        
+        # Setup paths
+        if storage_path is None:
+            storage_path = os.path.expanduser("~/.lxmf_html_server")
+        
+        self.storage_path = storage_path
+        self.pages_path = os.path.join(storage_path, "pages")
+        self.config_file = os.path.join(storage_path, "config.json")
+        self.access_log = os.path.join(storage_path, "access.log")
+        self.identity_file = identity_path or os.path.join(storage_path, "identity")
+        
+        # Server settings
+        self.enabled = True
+        self.transfer_mode = "embedded"
+        self.server_name = "LXMF HTML Server"
+        self.auto_announce_interval = 1800
+        self.auto_announce_enabled = True
+        
+        # Supported file types
+        self.supported_extensions = {
+            # HTML files
+            '.html': 'text/html',
+            '.htm': 'text/html',
+            # Text files
+            '.txt': 'text/plain',
+            '.md': 'text/markdown',
+            # Images
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.png': 'image/png',
+            '.gif': 'image/gif',
+            '.bmp': 'image/bmp',
+            '.webp': 'image/webp',
+            # Archives
+            '.zip': 'application/zip',
+            '.rar': 'application/x-rar-compressed',
+            '.7z': 'application/x-7z-compressed',
+            # Documents
+            '.pdf': 'application/pdf',
+        }
+        
+        # HTML field constants
+        self.FIELD_HTML_CONTENT = 10
+        self.FIELD_HTML_REQUEST = 11
+
+        # File transfer fields
+        self.FIELD_FILE_ATTACHMENTS = 0x02  # LXMF field for file attachments
+        
+        # Statistics
+        self.requests_served = 0
+        self.start_time = time.time()
+        self.last_announce = 0
+        
+        # Threading
+        self.announce_thread = None
+        self.status_thread = None
+        self.running = False
+        
+        # Initialize
+        self._init_storage()
+        self._load_config()
+        self._init_reticulum()
+        self._init_lxmf()
+        
+    def _init_storage(self):
+        """Create storage directories"""
+        for path in [self.storage_path, self.pages_path]:
+            if not os.path.exists(path):
+                os.makedirs(path)
+                self.ui.print_status('success', f"Created directory: {path}")
+        
+        if not os.listdir(self.pages_path):
+            self._create_default_pages()
+    
+    def _create_default_pages(self):
+        """Create default HTML pages with clickable navigation"""
+        self.ui.print_status('info', "Creating default pages...")
+        
+        # About page
+        about_html = """<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>About - LXMF Server</title>
+    <style>
+        body {
+            font-family: 'Courier New', monospace;
+            background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+            color: #0f0;
+            padding: 20px;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        h1 { 
+            color: #0f0; 
+            border-bottom: 2px solid #0f0; 
+            padding-bottom: 10px;
+            text-shadow: 0 0 10px #0f0;
+        }
+        .section {
+            background: rgba(0, 255, 0, 0.1);
+            padding: 20px;
+            margin: 20px 0;
+            border-radius: 5px;
+            border-left: 3px solid #0f0;
+        }
+        .section h2 { color: #0ff; margin-bottom: 15px; }
+        .section p { line-height: 1.6; margin: 10px 0; }
+        ul { margin-left: 20px; }
+        li { margin: 5px 0; }
+        .back-link {
+            display: inline-block;
+            margin-top: 20px;
+            padding: 10px 20px;
+            background: rgba(0, 255, 255, 0.2);
+            color: #0ff;
+            text-decoration: none;
+            border-radius: 5px;
+            border: 1px solid #0ff;
+        }
+        .back-link:hover {
+            background: rgba(0, 255, 255, 0.3);
+            box-shadow: 0 0 10px #0ff;
+        }
+    </style>
+</head>
+<body>
+    <h1>📖 About This Server</h1>
+    
+    <div class="section">
+        <h2>🔧 What is LXMF?</h2>
+        <p>LXMF (Lightweight Extensible Message Format) is a messaging protocol built on top of the Reticulum Network Stack.</p>
+        <p>It enables secure, decentralized communication over various transport mediums including:</p>
+        <ul>
+            <li>📡 LoRa radio networks</li>
+            <li>📻 Packet radio</li>
+            <li>📶 WiFi mesh networks</li>
+            <li>🌐 Internet (TCP/UDP)</li>
+            <li>🔌 Serial connections</li>
+        </ul>
+    </div>
+    
+    <div class="section">
+        <h2>✨ Features</h2>
+        <ul>
+            <li>🔒 End-to-end encryption</li>
+            <li>📴 Works offline and in mesh networks</li>
+            <li>🏢 No central servers required</li>
+            <li>📄 HTML content delivery</li>
+            <li>📉 Extremely low bandwidth</li>
+            <li>🔗 Clickable page navigation</li>
+            <li>📦 Multi-file type support (images, PDFs, archives)</li>
+        </ul>
+    </div>
+    
+    <div class="section">
+        <h2>📊 Server Stats</h2>
+        <p><strong>Started:</strong> {{timestamp}}</p>
+        <p><strong>Available Files:</strong> {{page_count}}</p>
+    </div>
+    
+    <a href="index" class="back-link">← Back to Index</a>
+</body>
+</html>"""
+        
+        with open(os.path.join(self.pages_path, "about.html"), 'w', encoding='utf-8') as f:
+            f.write(about_html)
+        
+        # Help page
+        help_html = """<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Help - LXMF Server</title>
+    <style>
+        body {
+            font-family: 'Courier New', monospace;
+            background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+            color: #0f0;
+            padding: 20px;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        h1 { 
+            color: #0f0; 
+            border-bottom: 2px solid #0f0; 
+            padding-bottom: 10px;
+            text-shadow: 0 0 10px #0f0;
+        }
+        .section {
+            background: rgba(0, 255, 0, 0.1);
+            padding: 20px;
+            margin: 20px 0;
+            border-radius: 5px;
+            border-left: 3px solid #0f0;
+        }
+        .section h2 { color: #0ff; margin-bottom: 15px; }
+        .section p { line-height: 1.6; margin: 10px 0; }
+        .code {
+            background: rgba(0, 0, 0, 0.5);
+            padding: 10px;
+            margin: 10px 0;
+            border-radius: 3px;
+            font-family: monospace;
+        }
+        .back-link {
+            display: inline-block;
+            margin-top: 20px;
+            padding: 10px 20px;
+            background: rgba(0, 255, 255, 0.2);
+            color: #0ff;
+            text-decoration: none;
+            border-radius: 5px;
+            border: 1px solid #0ff;
+        }
+        .back-link:hover {
+            background: rgba(0, 255, 255, 0.3);
+            box-shadow: 0 0 10px #0ff;
+        }
+    </style>
+</head>
+<body>
+    <h1>❓ Server Help</h1>
+    
+    <div class="section">
+        <h2>📝 Commands</h2>
+        <p>You can interact with this server using text commands:</p>
+        <div class="code">
+            <strong>GET:&lt;file&gt;</strong> - Request a specific file<br>
+            Example: GET:about.html
+        </div>
+        <div class="code">
+            <strong>list</strong> or <strong>pages</strong> - Get file listing
+        </div>
+        <div class="code">
+            <strong>announce</strong> or <strong>ping</strong> - Test connection
+        </div>
+    </div>
+    
+    <div class="section">
+        <h2>📁 Supported File Types</h2>
+        <p>This server can serve:</p>
+        <ul>
+            <li>🌐 HTML pages (.html, .htm)</li>
+            <li>📝 Text files (.txt, .md)</li>
+            <li>🖼️ Images (.jpg, .png, .gif, .webp)</li>
+            <li>📄 PDF documents (.pdf)</li>
+            <li>📦 Archives (.zip, .rar, .7z)</li>
+        </ul>
+    </div>
+    
+    <div class="section">
+        <h2>🖱️ Web Navigation</h2>
+        <p>If you're using an HTML-capable client, you can simply click links to navigate between pages!</p>
+    </div>
+    
+    <div class="section">
+        <h2>🔧 Server Information</h2>
+        <p><strong>Time:</strong> {{timestamp}}</p>
+        <p><strong>Files:</strong> {{page_count}}</p>
+    </div>
+    
+    <a href="index" class="back-link">← Back to Index</a>
+</body>
+</html>"""
+        
+        with open(os.path.join(self.pages_path, "help.html"), 'w', encoding='utf-8') as f:
+            f.write(help_html)
+        
+        self.ui.print_status('success', f"Created default pages in {self.pages_path}")
+    
+    def _load_config(self):
+        """Load server configuration"""
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                    self.enabled = config.get('enabled', True)
+                    self.transfer_mode = config.get('transfer_mode', 'embedded')
+                    self.server_name = config.get('server_name', 'LXMF HTML Server')
+                    self.auto_announce_interval = config.get('auto_announce_interval', 1800)
+                    self.auto_announce_enabled = config.get('auto_announce_enabled', True)
+            except Exception as e:
+                self.ui.print_status('warning', f"Could not load config: {e}")
+    
+    def _save_config(self):
+        """Save server configuration"""
+        config = {
+            'enabled': self.enabled,
+            'transfer_mode': self.transfer_mode,
+            'server_name': self.server_name,
+            'auto_announce_interval': self.auto_announce_interval,
+            'auto_announce_enabled': self.auto_announce_enabled
+        }
+        with open(self.config_file, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2)
+    
+    def _init_reticulum(self):
+        """Initialize Reticulum"""
+        self.ui.print_header("LXMF HTML Server - Initializing")
+        
+        try:
+            self.reticulum = RNS.Reticulum()
+            self.ui.print_status('success', "Reticulum initialized")
+            self._show_reticulum_status()
+        except Exception as e:
+            self.ui.print_status('error', f"Failed to initialize Reticulum: {e}")
+            sys.exit(1)
+        
+        # Load or create identity
+        if os.path.exists(self.identity_file):
+            self.identity = RNS.Identity.from_file(self.identity_file)
+            self.ui.print_status('success', f"Loaded identity")
+        else:
+            self.identity = RNS.Identity()
+            self.identity.to_file(self.identity_file)
+            self.ui.print_status('success', f"Created new identity")
+    
+    def _show_reticulum_status(self):
+        """Display Reticulum network status"""
+        try:
+            # Show interfaces
+            interfaces = RNS.Transport.interfaces
+            
+            # Handle both dict and list formats
+            if isinstance(interfaces, dict):
+                interface_list = list(interfaces.keys())
+                self.ui.print_status('interface', f"Active interfaces: {len(interface_list)}")
+                
+                for iface_name in interface_list[:3]:  # Show first 3
+                    iface = interfaces[iface_name]
+                    iface_type = iface.__class__.__name__
+                    self.ui.print_status('info', f"  └─ {iface_name} ({iface_type})")
+                
+                if len(interface_list) > 3:
+                    self.ui.print_status('info', f"  └─ ... and {len(interface_list)-3} more")
+            
+            elif isinstance(interfaces, list):
+                self.ui.print_status('interface', f"Active interfaces: {len(interfaces)}")
+                
+                for iface in interfaces[:3]:  # Show first 3
+                    iface_name = getattr(iface, 'name', 'Unknown')
+                    iface_type = iface.__class__.__name__
+                    self.ui.print_status('info', f"  └─ {iface_name} ({iface_type})")
+                
+                if len(interfaces) > 3:
+                    self.ui.print_status('info', f"  └─ ... and {len(interfaces)-3} more")
+            
+            else:
+                # Fallback if it's neither dict nor list
+                self.ui.print_status('interface', f"Interfaces initialized")
+            
+            # Show paths - try different attribute names for different RNS versions
+            try:
+                if hasattr(RNS.Transport, 'destination_table'):
+                    path_count = len(RNS.Transport.destination_table)
+                elif hasattr(RNS.Transport, 'destinations'):
+                    path_count = len(RNS.Transport.destinations)
+                elif hasattr(RNS.Transport, 'path_table'):
+                    path_count = len(RNS.Transport.path_table)
+                else:
+                    path_count = 0
+                
+                if path_count > 0:
+                    self.ui.print_status('path', f"Known paths: {path_count}")
+            except:
+                pass
+                
+        except Exception as e:
+            self.ui.print_status('warning', f"Could not read network status: {e}")
+    
+    def _init_lxmf(self):
+        """Initialize LXMF"""
+        self.message_router = LXMF.LXMRouter(
+            identity=self.identity,
+            storagepath=self.storage_path
+        )
+        
+        display_name = f"[HTML] {self.server_name}"
+        
+        self.lxmf_destination = self.message_router.register_delivery_identity(
+            self.identity,
+            display_name=display_name
+        )
+        
+        self.message_router.register_delivery_callback(self._handle_message)
+        
+        self.server_hash = RNS.prettyhexrep(self.lxmf_destination.hash)
+        
+        self._announce_server()
+        
+        self.ui.print_status('success', f"LXMF router initialized")
+        print(f"\n{self.ui.icon('network')} SERVER HASH: {self.server_hash}")
+        print(f"{self.ui.icon('info')} DISPLAY NAME: {display_name}\n")
+    
+    def _announce_server(self):
+        """Announce server"""
+        try:
+            self.lxmf_destination.announce()
+            self.last_announce = time.time()
+            
+            files = len(self._get_page_list())
+            self.ui.print_status('network', f"Server announced with {files} files")
+            
+        except Exception as e:
+            self.ui.print_status('error', f"Error announcing server: {e}")
+    
+    def _auto_announce_loop(self):
+        """Background thread for auto-announcing"""
+        while self.running:
+            try:
+                if self.auto_announce_enabled:
+                    time_since_announce = time.time() - self.last_announce
+                    
+                    if time_since_announce >= self.auto_announce_interval:
+                        self._announce_server()
+                
+                time.sleep(10)
+                
+            except Exception as e:
+                self.ui.print_status('error', f"Error in announce loop: {e}")
+    
+    def _log_access(self, sender_hash, page, success):
+        """Log page access"""
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        sender_short = RNS.prettyhexrep(sender_hash)
+        status = "SUCCESS" if success else "FAILED"
+        
+        log_entry = f"[{timestamp}] {sender_short} requested '{page}' - {status}\n"
+        
+        try:
+            with open(self.access_log, 'a', encoding='utf-8') as f:
+                f.write(log_entry)
+        except:
+            pass
+    
+    def _get_page_list(self):
+        """Get list of available files"""
+        files = []
+        try:
+            for filename in os.listdir(self.pages_path):
+                # Check if file has supported extension
+                ext = os.path.splitext(filename)[1].lower()
+                if ext in self.supported_extensions:
+                    files.append(filename)
+        except:
+            pass
+        return sorted(files)
+    
+    def _get_file_icon(self, filename):
+        """Get appropriate icon for file type"""
+        ext = os.path.splitext(filename)[1].lower()
+        
+        icons = {
+            '.html': '🌐',
+            '.htm': '🌐',
+            '.txt': '📝',
+            '.md': '📝',
+            '.jpg': '🖼️',
+            '.jpeg': '🖼️',
+            '.png': '🖼️',
+            '.gif': '🖼️',
+            '.bmp': '🖼️',
+            '.webp': '🖼️',
+            '.pdf': '📄',
+            '.zip': '📦',
+            '.rar': '📦',
+            '.7z': '📦',
+        }
+        
+        return icons.get(ext, '📄')
+    
+    def _get_mime_type(self, filename):
+        """Get MIME type for file"""
+        ext = os.path.splitext(filename)[1].lower()
+        return self.supported_extensions.get(ext, 'application/octet-stream')
+    
+    def _is_binary_file(self, filename):
+        """Check if file is binary"""
+        ext = os.path.splitext(filename)[1].lower()
+        text_extensions = ['.html', '.htm', '.txt', '.md']
+        return ext not in text_extensions
+    
+    def _process_template(self, html_content):
+        """Process template variables"""
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        files = self._get_page_list()
+        
+        # Generate clickable HTML links for {{page_list}}
+        file_links = []
+        for filename in files:
+            icon = self._get_file_icon(filename)
+            file_links.append(f'<a href="{filename}">{icon} {filename}</a>')
+        
+        page_list_html = '<br>\n'.join(file_links)
+        
+        html_content = html_content.replace('{{timestamp}}', timestamp)
+        html_content = html_content.replace('{{page_list}}', page_list_html)
+        html_content = html_content.replace('{{page_count}}', str(len(files)))
+        
+        return html_content
+
+    def _wrap_text_in_html(self, text_content, filename):
+        """Wrap text content as downloadable file"""
+        file_path = os.path.join(self.pages_path, filename)
+        file_size = os.path.getsize(file_path)
+        size_str = f"{file_size:,} bytes" if file_size < 1024 else f"{file_size/1024:.1f} KB"
+        
+        # Encode as base64 for download
+        base64_data = base64.b64encode(text_content.encode('utf-8')).decode('utf-8')
+        
+        html = f"""<!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>{filename} - Download</title>
+        <style>
+            body {{
+                font-family: 'Courier New', monospace;
+                background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+                color: #0f0;
+                padding: 20px;
+                max-width: 800px;
+                margin: 0 auto;
+            }}
+            h1 {{
+                color: #0ff;
+                border-bottom: 2px solid #0f0;
+                padding-bottom: 10px;
+                text-shadow: 0 0 10px #0ff;
+            }}
+            .file-info {{
+                background: rgba(0, 255, 0, 0.1);
+                padding: 20px;
+                border-radius: 5px;
+                border-left: 3px solid #0f0;
+                margin: 20px 0;
+            }}
+            .file-info p {{
+                margin: 10px 0;
+            }}
+            .download-section {{
+                background: rgba(0, 255, 255, 0.1);
+                padding: 30px;
+                border-radius: 5px;
+                margin: 20px 0;
+                text-align: center;
+            }}
+            .download-btn {{
+                display: inline-block;
+                padding: 20px 40px;
+                background: rgba(0, 255, 0, 0.3);
+                color: #0f0;
+                text-decoration: none;
+                border-radius: 5px;
+                border: 2px solid #0f0;
+                margin: 10px;
+                font-size: 1.3em;
+                cursor: pointer;
+            }}
+            .download-btn:hover {{
+                background: rgba(0, 255, 0, 0.5);
+                box-shadow: 0 0 15px #0f0;
+            }}
+            .preview {{
+                background: rgba(0, 0, 0, 0.5);
+                padding: 15px;
+                border-radius: 5px;
+                margin: 20px 0;
+                max-height: 300px;
+                overflow-y: auto;
+                border: 1px solid #0f0;
+            }}
+            .preview pre {{
+                margin: 0;
+                white-space: pre-wrap;
+                word-wrap: break-word;
+                color: #0ff;
+            }}
+            .back-link {{
+                display: inline-block;
+                margin-top: 20px;
+                padding: 10px 20px;
+                background: rgba(0, 255, 255, 0.2);
+                color: #0ff;
+                text-decoration: none;
+                border-radius: 5px;
+                border: 1px solid #0ff;
+            }}
+            .back-link:hover {{
+                background: rgba(0, 255, 255, 0.3);
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>📝 {filename}</h1>
+        
+        <div class="file-info">
+            <p><strong>Filename:</strong> {filename}</p>
+            <p><strong>Size:</strong> {size_str}</p>
+            <p><strong>Type:</strong> Text File</p>
+            <p><strong>Status:</strong> <span style="color: #0f0;">✓ Ready for Download</span></p>
+        </div>
+        
+        <div class="download-section">
+            <p style="color: #0ff; margin-bottom: 20px; font-size: 1.1em;">File is ready to download</p>
+            <a href="data:text/plain;base64,{base64_data}" download="{filename}" class="download-btn">
+                ⬇️ Download {filename}
+            </a>
+            <p style="color: #888; margin-top: 15px; font-size: 0.9em;">
+                Click to save the file to your device
+            </p>
+        </div>
+        
+        <div class="file-info">
+            <p><strong>Preview:</strong></p>
+            <div class="preview">
+                <pre>{text_content[:500]}{'...' if len(text_content) > 500 else ''}</pre>
+            </div>
+        </div>
+        
+        <a href="index" class="back-link">← Back to Index</a>
+    </body>
+    </html>"""
+        return html
+
+    def _wrap_image_in_html(self, base64_data, filename, mime_type):
+        """Wrap image as downloadable file with preview"""
+        file_path = os.path.join(self.pages_path, filename)
+        file_size = os.path.getsize(file_path)
+        size_str = f"{file_size:,} bytes" if file_size < 1024 else f"{file_size/1024:.1f} KB"
+        if file_size >= 1024*1024:
+            size_str = f"{file_size/(1024*1024):.2f} MB"
+        
+        html = f"""<!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>{filename} - Download</title>
+        <style>
+            body {{
+                font-family: 'Courier New', monospace;
+                background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+                color: #0f0;
+                padding: 20px;
+                max-width: 1000px;
+                margin: 0 auto;
+            }}
+            h1 {{
+                color: #0ff;
+                text-align: center;
+                margin-bottom: 10px;
+                text-shadow: 0 0 10px #0ff;
+            }}
+            .file-info {{
+                background: rgba(0, 255, 0, 0.1);
+                padding: 15px;
+                border-radius: 5px;
+                border-left: 3px solid #0f0;
+                margin: 20px 0;
+                text-align: center;
+            }}
+            .file-info p {{
+                margin: 5px 0;
+            }}
+            .image-preview {{
+                background: rgba(0, 255, 0, 0.05);
+                padding: 20px;
+                border-radius: 5px;
+                margin: 20px 0;
+                text-align: center;
+            }}
+            img {{
+                max-width: 100%;
+                height: auto;
+                border: 2px solid #0f0;
+                border-radius: 5px;
+                box-shadow: 0 0 20px rgba(0, 255, 0, 0.3);
+            }}
+            .download-section {{
+                text-align: center;
+                margin: 30px 0;
+            }}
+            .download-btn {{
+                display: inline-block;
+                padding: 20px 40px;
+                background: rgba(0, 255, 0, 0.3);
+                color: #0f0;
+                text-decoration: none;
+                border-radius: 5px;
+                border: 2px solid #0f0;
+                font-size: 1.3em;
+                cursor: pointer;
+            }}
+            .download-btn:hover {{
+                background: rgba(0, 255, 0, 0.5);
+                box-shadow: 0 0 15px #0f0;
+            }}
+            .back-link {{
+                display: inline-block;
+                margin-top: 20px;
+                padding: 10px 20px;
+                background: rgba(0, 255, 255, 0.2);
+                color: #0ff;
+                text-decoration: none;
+                border-radius: 5px;
+                border: 1px solid #0ff;
+            }}
+            .back-link:hover {{
+                background: rgba(0, 255, 255, 0.3);
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>🖼️ {filename}</h1>
+        
+        <div class="file-info">
+            <p><strong>Size:</strong> {size_str} | <strong>Type:</strong> {mime_type}</p>
+            <p style="color: #0f0;">✓ Ready for Download</p>
+        </div>
+        
+        <div class="image-preview">
+            <img src="data:{mime_type};base64,{base64_data}" alt="{filename}">
+        </div>
+        
+        <div class="download-section">
+            <a href="data:{mime_type};base64,{base64_data}" download="{filename}" class="download-btn">
+                ⬇️ Download Image
+            </a>
+            <p style="color: #888; margin-top: 15px;">Click to save to your device</p>
+        </div>
+        
+        <div style="text-align: center;">
+            <a href="index" class="back-link">← Back to Index</a>
+        </div>
+    </body>
+    </html>"""
+        return html
+
+    def _wrap_binary_in_html(self, base64_data, filename, mime_type):
+        """Wrap binary file as downloadable with info"""
+        file_path = os.path.join(self.pages_path, filename)
+        file_size = os.path.getsize(file_path)
+        size_str = f"{file_size:,} bytes" if file_size < 1024 else f"{file_size/1024:.2f} KB"
+        if file_size >= 1024*1024:
+            size_str = f"{file_size/(1024*1024):.2f} MB"
+        
+        # Determine file type icon and description
+        ext = os.path.splitext(filename)[1].lower()
+        if ext == '.pdf':
+            icon = '📄'
+            type_desc = 'PDF Document'
+        elif ext in ['.zip', '.rar', '.7z']:
+            icon = '📦'
+            type_desc = 'Archive File'
+        else:
+            icon = '📁'
+            type_desc = 'Binary File'
+        
+        html = f"""<!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>{filename} - Download</title>
+        <style>
+            body {{
+                font-family: 'Courier New', monospace;
+                background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+                color: #0f0;
+                padding: 20px;
+                max-width: 800px;
+                margin: 0 auto;
+            }}
+            h1 {{
+                color: #0ff;
+                text-align: center;
+                margin-bottom: 20px;
+                text-shadow: 0 0 10px #0ff;
+            }}
+            .file-icon {{
+                text-align: center;
+                font-size: 5em;
+                margin: 20px 0;
+            }}
+            .file-info {{
+                background: rgba(0, 255, 0, 0.1);
+                padding: 20px;
+                border-radius: 5px;
+                border-left: 3px solid #0f0;
+                margin: 20px 0;
+            }}
+            .file-info p {{
+                margin: 10px 0;
+                font-size: 1.1em;
+            }}
+            .download-section {{
+                background: rgba(0, 255, 255, 0.1);
+                padding: 40px;
+                border-radius: 5px;
+                margin: 30px 0;
+                text-align: center;
+            }}
+            .download-btn {{
+                display: inline-block;
+                padding: 25px 50px;
+                background: rgba(0, 255, 0, 0.3);
+                color: #0f0;
+                text-decoration: none;
+                border-radius: 5px;
+                border: 3px solid #0f0;
+                font-size: 1.5em;
+                font-weight: bold;
+                cursor: pointer;
+            }}
+            .download-btn:hover {{
+                background: rgba(0, 255, 0, 0.5);
+                box-shadow: 0 0 20px #0f0;
+                transform: scale(1.05);
+                transition: all 0.3s;
+            }}
+            .info-note {{
+                background: rgba(0, 255, 255, 0.1);
+                padding: 15px;
+                border-radius: 5px;
+                margin: 20px 0;
+                border: 1px solid #0ff;
+                color: #0ff;
+            }}
+            .back-link {{
+                display: inline-block;
+                margin-top: 20px;
+                padding: 10px 20px;
+                background: rgba(0, 255, 255, 0.2);
+                color: #0ff;
+                text-decoration: none;
+                border-radius: 5px;
+                border: 1px solid #0ff;
+            }}
+            .back-link:hover {{
+                background: rgba(0, 255, 255, 0.3);
+            }}
+        </style>
+    </head>
+    <body>
+        <div class="file-icon">{icon}</div>
+        <h1>{filename}</h1>
+        
+        <div class="file-info">
+            <p><strong>Filename:</strong> {filename}</p>
+            <p><strong>Type:</strong> {type_desc}</p>
+            <p><strong>Size:</strong> {size_str}</p>
+            <p><strong>MIME:</strong> {mime_type}</p>
+            <p><strong>Status:</strong> <span style="color: #0f0;">✓ Ready for Download</span></p>
+        </div>
+        
+        <div class="download-section">
+            <p style="color: #0ff; margin-bottom: 25px; font-size: 1.2em;">File is ready to download</p>
+            <a href="data:{mime_type};base64,{base64_data}" download="{filename}" class="download-btn">
+                ⬇️ DOWNLOAD
+            </a>
+            <p style="color: #888; margin-top: 20px; font-size: 0.95em;">
+                Click the button above to save this file
+            </p>
+        </div>
+        
+        <div class="info-note">
+            <strong>ℹ️ Note:</strong> This file will be downloaded to your device's default download location.
+            The download behavior may vary depending on your browser or client.
+        </div>
+        
+        <div style="text-align: center;">
+            <a href="index" class="back-link">← Back to Index</a>
+        </div>
+    </body>
+    </html>"""
+        
+        return html    
+    
+    def _generate_dynamic_index(self):
+        """Generate dynamic HTML index with clickable links"""
+        files = self._get_page_list()
+        
+        # Group files by type
+        file_groups = {
+            'HTML Pages': [],
+            'Text Files': [],
+            'Images': [],
+            'Documents': [],
+            'Archives': []
+        }
+        
+        for filename in files:
+            ext = os.path.splitext(filename)[1].lower()
+            file_path = os.path.join(self.pages_path, filename)
+            size = os.path.getsize(file_path)
+            size_str = f"{size:,} bytes" if size < 1024 else f"{size/1024:.1f} KB"
+            icon = self._get_file_icon(filename)
+            
+            item_html = f"""                <li class="file-item">
+                    <a href="{filename}" class="file-link">{icon} {filename}</a>
+                    <div class="file-info">Size: {size_str}</div>
+                </li>"""
+            
+            if ext in ['.html', '.htm']:
+                file_groups['HTML Pages'].append(item_html)
+            elif ext in ['.txt', '.md']:
+                file_groups['Text Files'].append(item_html)
+            elif ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']:
+                file_groups['Images'].append(item_html)
+            elif ext == '.pdf':
+                file_groups['Documents'].append(item_html)
+            elif ext in ['.zip', '.rar', '.7z']:
+                file_groups['Archives'].append(item_html)
+        
+        # Build sections
+        sections_html = ""
+        for group_name, items in file_groups.items():
+            if items:
+                sections_html += f"""
+        <div class="file-group">
+            <h3>{group_name} ({len(items)})</h3>
+            <ul class="file-list">
+{''.join(items)}
+            </ul>
+        </div>"""
+        
+        # Full index HTML
+        index_html = f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>LXMF HTML Server - Index</title>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{
+            font-family: 'Courier New', monospace;
+            background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+            color: #0f0;
+            padding: 20px;
+            min-height: 100vh;
+        }}
+        .container {{
+            max-width: 900px;
+            margin: 0 auto;
+            background: rgba(0, 0, 0, 0.8);
+            border: 2px solid #0f0;
+            border-radius: 10px;
+            padding: 30px;
+            box-shadow: 0 0 30px rgba(0, 255, 0, 0.3);
+        }}
+        h1 {{
+            color: #0f0;
+            text-align: center;
+            margin-bottom: 10px;
+            font-size: 2em;
+            text-shadow: 0 0 10px #0f0;
+        }}
+        .subtitle {{
+            text-align: center;
+            color: #0ff;
+            margin-bottom: 30px;
+            opacity: 0.8;
+        }}
+        .info {{
+            background: rgba(0, 255, 0, 0.1);
+            border-left: 3px solid #0f0;
+            padding: 15px;
+            margin: 20px 0;
+            border-radius: 5px;
+        }}
+        .info h2 {{
+            color: #0ff;
+            margin-bottom: 10px;
+            font-size: 1.2em;
+        }}
+        .file-group {{
+            margin: 25px 0;
+        }}
+        .file-group h3 {{
+            color: #0ff;
+            margin-bottom: 10px;
+            padding-bottom: 5px;
+            border-bottom: 1px solid #0f0;
+        }}
+        .file-list {{
+            list-style: none;
+            padding: 0;
+        }}
+        .file-item {{
+            background: rgba(0, 255, 255, 0.1);
+            margin: 8px 0;
+            padding: 12px;
+            border-radius: 5px;
+            transition: all 0.3s;
+        }}
+        .file-item:hover {{
+            background: rgba(0, 255, 255, 0.2);
+            transform: translateX(5px);
+        }}
+        .file-link {{
+            color: #0ff;
+            text-decoration: none;
+            font-size: 1.1em;
+            display: block;
+        }}
+        .file-link:hover {{
+            color: #0f0;
+            text-shadow: 0 0 5px #0ff;
+        }}
+        .file-info {{
+            color: #888;
+            font-size: 0.85em;
+            margin-top: 5px;
+        }}
+        .footer {{
+            text-align: center;
+            margin-top: 30px;
+            padding-top: 20px;
+            border-top: 1px solid #0f0;
+            color: #888;
+            font-size: 0.9em;
+        }}
+        @keyframes pulse {{
+            0%, 100% {{ opacity: 1; }}
+            50% {{ opacity: 0.5; }}
+        }}
+        .pulse {{ animation: pulse 2s infinite; }}
+        .status-indicator {{
+            display: inline-block;
+            width: 10px;
+            height: 10px;
+            background: #0f0;
+            border-radius: 50%;
+            margin-right: 8px;
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>📡 LXMF HTML Server</h1>
+        <div class="subtitle">Decentralized Web Over Mesh Networks</div>
+        
+        <div class="info">
+            <h2>🌐 Server Information</h2>
+            <p><span class="status-indicator pulse"></span><strong>Status:</strong> ONLINE</p>
+            <p><strong>Time:</strong> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
+            <p><strong>Total Files:</strong> {len(files)}</p>
+            <p><strong>Protocol:</strong> LXMF over Reticulum</p>
+        </div>
+        
+        <div class="info">
+            <h2>📚 Available Files</h2>
+{sections_html}
+        </div>
+        
+        <div class="info">
+            <h2>💡 Usage</h2>
+            <p>Click any file link above to view/download, or send manual requests:</p>
+            <p style="margin-top: 10px; font-family: monospace; background: rgba(0,0,0,0.5); padding: 10px; border-radius: 3px;">
+                GET:&lt;filename&gt;<br>
+                Example: GET:about.html
+            </p>
+        </div>
+        
+        <div class="footer">
+            Powered by Standalone LXMF HTML Server<br>
+            Reticulum Network Stack
+        </div>
+    </div>
+</body>
+</html>"""
+        
+        return index_html
+    
+    def _generate_text_index(self):
+        """Generate text-based file index"""
+        files = self._get_page_list()
+        
+        if not files:
+            return "No files available"
+        
+        text = f"{self.ui.icon('page')} Available Files ({len(files)}):\n\n"
+        
+        for i, filename in enumerate(files, 1):
+            file_path = os.path.join(self.pages_path, filename)
+            size = os.path.getsize(file_path)
+            size_str = f"{size:,}B" if size < 1024 else f"{size/1024:.1f}KB"
+            icon = self._get_file_icon(filename)
+            text += f"  [{i}] {icon} {filename} ({size_str})\n"
+        
+        text += f"\n{self.ui.icon('info')} To view a file, send: GET:<filename>\n"
+        text += f"Example: GET:{files[0]}\n"
+        text += f"Send 'list' or 'pages' to see this index again"
+        
+        return text
+
+    def _create_auto_download_html(self, base64_data, filename, mime_type):
+        """Create minimal HTML that auto-downloads the file"""
+        html = f"""<!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <title>Downloading {filename}</title>
+        <style>
+            body {{
+                font-family: 'Courier New', monospace;
+                background: #1a1a1a;
+                color: #0f0;
+                padding: 50px;
+                text-align: center;
+            }}
+            .message {{
+                font-size: 1.5em;
+                margin: 20px 0;
+            }}
+            .filename {{
+                color: #0ff;
+                font-size: 1.2em;
+                margin: 20px 0;
+            }}
+            a {{
+                display: inline-block;
+                margin-top: 20px;
+                padding: 15px 30px;
+                background: rgba(0, 255, 0, 0.3);
+                color: #0f0;
+                text-decoration: none;
+                border-radius: 5px;
+                border: 2px solid #0f0;
+                font-size: 1.2em;
+            }}
+            a:hover {{
+                background: rgba(0, 255, 0, 0.5);
+            }}
+            .back {{
+                margin-top: 30px;
+                padding: 10px 20px;
+                background: rgba(0, 255, 255, 0.2);
+                color: #0ff;
+                border: 1px solid #0ff;
+                font-size: 1em;
+            }}
+        </style>
+        <script>
+            window.onload = function() {{
+                // Auto-download on page load
+                var link = document.getElementById('download-link');
+                link.click();
+            }};
+        </script>
+    </head>
+    <body>
+        <div class="message">⬇️ Downloading...</div>
+        <div class="filename">{filename}</div>
+        <p>If download doesn't start automatically:</p>
+        <a id="download-link" href="data:{mime_type};base64,{base64_data}" download="{filename}">
+            Click Here to Download
+        </a>
+        <br>
+        <a href="index" class="back">← Back to Index</a>
+    </body>
+    </html>"""
+        return html
+    
+    def _send_file(self, dest_hash, file_path, filename):
+        """Send file as LXMF attachment for download"""
+        try:
+            dest_identity = RNS.Identity.recall(dest_hash)
+            
+            if not dest_identity:
+                self.ui.print_status('warning', "Client identity not in cache, requesting path...")
+                RNS.Transport.request_path(dest_hash)
+                
+                max_wait = 15
+                wait_interval = 0.5
+                waited = 0
+                
+                while waited < max_wait:
+                    time.sleep(wait_interval)
+                    waited += wait_interval
+                    dest_identity = RNS.Identity.recall(dest_hash)
+                    if dest_identity:
+                        self.ui.print_status('success', "Identity received")
+                        break
+                    
+                    if int(waited) % 3 == 0:
+                        self.ui.print_status('info', f"Still waiting... ({int(waited)}s)")
+                
+                if not dest_identity:
+                    self.ui.print_status('error', f"Could not establish path")
+                    return False
+            
+            dest = RNS.Destination(
+                dest_identity,
+                RNS.Destination.OUT,
+                RNS.Destination.SINGLE,
+                "lxmf", "delivery"
+            )
+            
+            # Read file data
+            with open(file_path, 'rb') as f:
+                file_data = f.read()
+            
+            # Get file size
+            file_size = len(file_data)
+            size_str = f"{file_size:,} bytes" if file_size < 1024 else f"{file_size/1024:.1f} KB"
+            if file_size >= 1024*1024:
+                size_str = f"{file_size/(1024*1024):.2f} MB"
+            
+            # Create file attachment tuple: (filename, file_data)
+            file_attachment = (filename, file_data)
+            
+            # Create LXMF message with file attachment
+            lxmf_message = LXMF.LXMessage(
+                dest,
+                self.lxmf_destination,
+                f"File: {filename} ({size_str})",
+                title=filename,
+                fields={
+                    self.FIELD_FILE_ATTACHMENTS: [file_attachment]
+                }
+            )
+            
+            self.message_router.handle_outbound(lxmf_message)
+            self.ui.print_status('success', f"File queued for delivery: {filename} ({size_str})")
+            return True
+            
+        except Exception as e:
+            self.ui.print_status('error', f"Error sending file: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
+    def _serve_page(self, sender_hash, page_name):
+        """Serve file to requester"""
+        try:
+            page_name = os.path.basename(page_name)
+            
+            # Handle index/list requests - ALWAYS generate dynamic index for these
+            if not page_name or page_name.lower() in ['index', '_index', '_list', 'list', '']:
+                html_content = self._generate_dynamic_index()
+                text_index = self._generate_text_index()
+                
+                self._send_html(sender_hash, html_content, "File Index")
+                self._send_simple_message(sender_hash, text_index)
+                
+                self._log_access(sender_hash, "INDEX", True)
+                self.ui.print_status('response', f"Served INDEX to {RNS.prettyhexrep(sender_hash)}")
+                return True
+            
+            # For any other file, try to serve it
+            file_path = os.path.join(self.pages_path, page_name)
+            
+            if not os.path.exists(file_path):
+                error_html = f"""<!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <title>404 Not Found</title>
+        <style>
+            body {{
+                font-family: monospace;
+                background: #1a1a1a;
+                color: #f00;
+                padding: 50px;
+                text-align: center;
+            }}
+            h1 {{ font-size: 3em; text-shadow: 0 0 10px #f00; }}
+            a {{
+                color: #0ff;
+                text-decoration: none;
+                margin-top: 20px;
+                display: inline-block;
+                padding: 10px 20px;
+                border: 1px solid #0ff;
+                border-radius: 5px;
+            }}
+            a:hover {{
+                background: rgba(0, 255, 255, 0.2);
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>404 - File Not Found</h1>
+        <p>The requested file '{page_name}' does not exist.</p>
+        <a href="index">← Back to Index</a>
+    </body>
+    </html>"""
+                self._send_html(sender_hash, error_html, f"404: {page_name}")
+                self._log_access(sender_hash, page_name, False)
+                self.ui.print_status('error', f"404: {page_name}")
+                return False
+            
+            # Determine file type
+            ext = os.path.splitext(page_name)[1].lower()
+            
+            # HTML files - send as HTML content for rendering
+            if ext in ['.html', '.htm']:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    html_content = f.read()
+                # Process templates
+                html_content = self._process_template(html_content)
+                
+                self._send_html(sender_hash, html_content, f"Serving: {page_name}")
+                self._log_access(sender_hash, page_name, True)
+                self.requests_served += 1
+                
+                self.ui.print_status('response', f"Served '{page_name}' (HTML) to {RNS.prettyhexrep(sender_hash)}")
+                return True
+            
+            # All other files - send as file attachment for download
+            else:
+                self._send_file(sender_hash, file_path, page_name)
+                self._log_access(sender_hash, page_name, True)
+                self.requests_served += 1
+                
+                mime_type = self._get_mime_type(page_name)
+                self.ui.print_status('response', f"Sent file '{page_name}' ({mime_type}) to {RNS.prettyhexrep(sender_hash)}")
+                return True
+            
+        except Exception as e:
+            self.ui.print_status('error', f"Error serving file: {e}")
+            import traceback
+            traceback.print_exc()
+            self._log_access(sender_hash, page_name, False)
+            return False
+    
+    def _send_html(self, dest_hash, html_content, message_text):
+        """Send HTML content via LXMF"""
+        try:
+            dest_identity = RNS.Identity.recall(dest_hash)
+            
+            if not dest_identity:
+                self.ui.print_status('warning', "Client identity not in cache, requesting path...")
+                RNS.Transport.request_path(dest_hash)
+                
+                max_wait = 15
+                wait_interval = 0.5
+                waited = 0
+                
+                while waited < max_wait:
+                    time.sleep(wait_interval)
+                    waited += wait_interval
+                    dest_identity = RNS.Identity.recall(dest_hash)
+                    if dest_identity:
+                        self.ui.print_status('success', "Identity received")
+                        break
+                    
+                    if int(waited) % 3 == 0:
+                        self.ui.print_status('info', f"Still waiting... ({int(waited)}s)")
+                
+                if not dest_identity:
+                    self.ui.print_status('error', f"Could not establish path")
+                    return False
+            
+            dest = RNS.Destination(
+                dest_identity,
+                RNS.Destination.OUT,
+                RNS.Destination.SINGLE,
+                "lxmf", "delivery"
+            )
+            
+            lxmf_message = LXMF.LXMessage(
+                dest,
+                self.lxmf_destination,
+                message_text,
+                title="",
+                fields={self.FIELD_HTML_CONTENT: html_content}
+            )
+            
+            self.message_router.handle_outbound(lxmf_message)
+            self.ui.print_status('success', "HTML message queued for delivery")
+            return True
+            
+        except Exception as e:
+            self.ui.print_status('error', f"Error sending HTML: {e}")
+            return False
+    
+    def _send_simple_message(self, dest_hash, text):
+        """Send a simple text message"""
+        try:
+            dest_identity = RNS.Identity.recall(dest_hash)
+            
+            if not dest_identity:
+                RNS.Transport.request_path(dest_hash)
+                time.sleep(2)
+                dest_identity = RNS.Identity.recall(dest_hash)
+                
+                if not dest_identity:
+                    return False
+            
+            dest = RNS.Destination(
+                dest_identity,
+                RNS.Destination.OUT,
+                RNS.Destination.SINGLE,
+                "lxmf", "delivery"
+            )
+            
+            simple_message = LXMF.LXMessage(dest, self.lxmf_destination, text)
+            self.message_router.handle_outbound(simple_message)
+            return True
+            
+        except Exception as e:
+            self.ui.print_status('error', f"Error sending message: {e}")
+            return False
+    
+    def _handle_message(self, message):
+        """Handle incoming LXMF messages"""
+        try:
+            sender_hash = message.source_hash
+            content = message.content.decode('utf-8') if isinstance(message.content, bytes) else message.content
+            
+            sender_full = RNS.prettyhexrep(sender_hash)
+            self.ui.print_status('request', f"Request from {sender_full}: {content[:50]}")
+            
+            # Check for HTML request in fields
+            if hasattr(message, 'fields') and message.fields:
+                if self.FIELD_HTML_REQUEST in message.fields:
+                    page_name = message.fields[self.FIELD_HTML_REQUEST]
+                    self._serve_page(sender_hash, page_name)
+                    return
+            
+            content_lower = content.lower().strip()
+            
+            # Index/list requests
+            if content_lower in ['list', 'pages', 'dir', 'ls', '_index', '_list']:
+                self._serve_page(sender_hash, '_index')
+                return
+            
+            # "index" command
+            if content_lower == 'index':
+                self._serve_page(sender_hash, 'index')
+                return
+            
+            # GET requests
+            if content.startswith("GET:") or content.startswith("get:"):
+                page_name = content[4:].strip()
+                self._serve_page(sender_hash, page_name)
+                return
+            
+            # Announce request
+            if content_lower in ['announce', 'hello', 'ping']:
+                self.ui.print_status('info', "Client announced itself")
+                self._send_simple_message(sender_hash, "Server received your announcement")
+                return
+            
+            # Default: show help
+            help_text = f"""{self.ui.icon('server')} LXMF HTML Server
+
+Available commands:
+- GET:<file> - Request a specific file
+- list or pages - Get file listing
+- index - Get file index
+- announce - Announce your presence
+
+Supported file types:
+🌐 HTML (.html, .htm)
+📝 Text (.txt, .md)
+🖼️ Images (.jpg, .png, .gif, .webp)
+📄 PDF (.pdf)
+📦 Archives (.zip, .rar, .7z)
+
+Example: GET:about.html
+
+Server: {self.server_hash}
+Files: {len(self._get_page_list())}
+"""
+            self._send_simple_message(sender_hash, help_text)
+            
+        except Exception as e:
+            self.ui.print_status('error', f"Error handling message: {e}")
+            import traceback
+            traceback.print_exc()
+    
+    def show_stats(self):
+        """Display server statistics"""
+        uptime = time.time() - self.start_time
+        hours = int(uptime // 3600)
+        minutes = int((uptime % 3600) // 60)
+        
+        time_since_announce = time.time() - self.last_announce
+        next_announce = max(0, self.auto_announce_interval - time_since_announce)
+        
+        self.ui.print_header("SERVER STATISTICS")
+        print(f"{self.ui.icon('online')} Status: {'ENABLED' if self.enabled else 'DISABLED'}")
+        print(f"{self.ui.icon('time')} Uptime: {hours}h {minutes}m")
+        print(f"{self.ui.icon('stats')} Requests served: {self.requests_served}")
+        print(f"{self.ui.icon('page')} Files available: {len(self._get_page_list())}")
+        print(f"{self.ui.icon('info')} Files directory: {self.pages_path}")
+        print(f"\n{self.ui.icon('network')} Auto-announce: {'ENABLED' if self.auto_announce_enabled else 'DISABLED'}")
+        print(f"{self.ui.icon('time')} Announce interval: {self.auto_announce_interval}s ({self.auto_announce_interval//60}min)")
+        if self.auto_announce_enabled and next_announce > 0:
+            print(f"{self.ui.icon('info')} Next announce in: {int(next_announce)}s ({int(next_announce//60)}min)")
+        
+        # File types breakdown
+        files = self._get_page_list()
+        file_types = {}
+        for f in files:
+            ext = os.path.splitext(f)[1].lower()
+            file_types[ext] = file_types.get(ext, 0) + 1
+        
+        print(f"\n{self.ui.icon('page')} File types:")
+        for ext, count in sorted(file_types.items()):
+            print(f"  {ext}: {count}")
+        
+        # Network status
+        try:
+            interfaces = RNS.Transport.interfaces
+            
+            if isinstance(interfaces, dict):
+                interface_count = len(interfaces)
+            elif isinstance(interfaces, list):
+                interface_count = len(interfaces)
+            else:
+                interface_count = 0
+            
+            try:
+                if hasattr(RNS.Transport, 'destination_table'):
+                    path_count = len(RNS.Transport.destination_table)
+                elif hasattr(RNS.Transport, 'destinations'):
+                    path_count = len(RNS.Transport.destinations)
+                elif hasattr(RNS.Transport, 'path_table'):
+                    path_count = len(RNS.Transport.path_table)
+                else:
+                    path_count = 0
+            except:
+                path_count = 0
+            
+            print(f"\n{self.ui.icon('interface')} Active interfaces: {interface_count}")
+            print(f"{self.ui.icon('path')} Known paths: {path_count}")
+        except Exception as e:
+            self.ui.print_status('warning', f"Could not read network status: {e}")
+        
+        print("="*60 + "\n")
+    
+    def set_announce_interval(self, seconds):
+        """Set auto-announce interval"""
+        if seconds < 60:
+            self.ui.print_status('warning', "Minimum interval is 60 seconds")
+            return False
+        
+        self.auto_announce_interval = seconds
+        self._save_config()
+        self.ui.print_status('success', f"Auto-announce interval set to {seconds}s ({seconds//60}min)")
+        return True
+    
+    def run(self):
+        """Run the server"""
+        self.running = True
+        
+        # Start auto-announce thread
+        self.announce_thread = threading.Thread(target=self._auto_announce_loop, daemon=True)
+        self.announce_thread.start()
+        
+        self.ui.print_status('online', f"Server started: {self.server_name}")
+        self.ui.print_status('info', "Listening for requests...")
+        self.ui.print_status('network', f"Auto-announce: {'ENABLED' if self.auto_announce_enabled else 'DISABLED'} ({self.auto_announce_interval}s)")
+        
+        print(f"\n{self.ui.icon('info')} Supported file types:")
+        print(f"   🌐 HTML, 📝 Text, 🖼️ Images, 📄 PDF, 📦 Archives")
+        print(f"\n{self.ui.icon('info')} Clients can request files using:")
+        print(f"   • GET:<filename>")
+        print(f"   • 'index' or 'list' for file listing")
+        print(f"   • Click links in HTML pages\n")
+        
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            print("\n")
+            self.ui.print_status('warning', "Server stopping...")
+            self.running = False
+            self.show_stats()
+            self.ui.print_status('info', "Goodbye!\n")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Standalone LXMF HTML Server with Multi-File Support',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s                              # Start server with default settings
+  %(prog)s --storage ~/myserver         # Use custom storage path
+  %(prog)s --name "My Server"           # Set custom server name
+  %(prog)s --announce-interval 3600     # Announce every hour
+  %(prog)s --no-auto-announce           # Disable auto-announce
+  %(prog)s --stats                      # Show statistics
+  
+Supported file types:
+  - HTML pages (.html, .htm)
+  - Text files (.txt, .md)
+  - Images (.jpg, .png, .gif, .webp, .bmp)
+  - PDF documents (.pdf)
+  - Archives (.zip, .rar, .7z)
+        """
+    )
+    
+    parser.add_argument('--storage', type=str, default=None,
+                       help='Storage path (default: ~/.lxmf_html_server)')
+    parser.add_argument('--identity', type=str, default=None,
+                       help='Path to identity file')
+    parser.add_argument('--name', type=str, default=None,
+                       help='Server display name')
+    parser.add_argument('--announce-interval', type=int, default=None,
+                       help='Auto-announce interval in seconds (default: 1800)')
+    parser.add_argument('--no-auto-announce', action='store_true',
+                       help='Disable automatic announcements')
+    parser.add_argument('--stats', action='store_true',
+                       help='Show statistics and exit')
+    
+    args = parser.parse_args()
+    
+    server = LXMFHTMLServer(storage_path=args.storage, identity_path=args.identity)
+    
+    # Apply --name argument BEFORE saving config
+    if args.name is not None:
+        server.server_name = args.name
+    
+    if args.announce_interval is not None:
+        server.set_announce_interval(args.announce_interval)
+    
+    if args.no_auto_announce:
+        server.auto_announce_enabled = False
+    
+    # Save config after applying all settings
+    server._save_config()
+    
+    if args.stats:
+        server.show_stats()
+    else:
+        server.run()
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file