Add files via upload

1 files changed, 121 insertions, 0 deletions

diff --git a/mesh_chat.py b/mesh_chat.py
new file mode 100644
index 0000000..f44edc9
--- /dev/null
+++ b/mesh_chat.py
@@ -0,0 +1,121 @@
+
+import os
+import sys
+import asyncio
+import logging
+import socket
+from network.tor_manager import TorManager
+from network.mesh import MeshNetwork
+from ui.chat_window import ChatWindow
+from security.memory import SecureMemory
+from security.crypto import CryptoManager
+
+class MeshChat:
+    def __init__(self):
+        # Configure logging
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        self.logger = logging.getLogger('MeshChat')
+
+        # Initialize components
+        self.tor_manager = TorManager()
+        self.mesh_network = MeshNetwork(base_port=12345, max_retry_ports=5)
+        self.crypto = CryptoManager()
+        self.secure_memory = SecureMemory()
+
+    async def _verify_network(self) -> bool:
+        """Verify network components are running"""
+        try:
+            # Try connecting to health check endpoint
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.connect(('127.0.0.1', 12345))
+            sock.close()
+            self.logger.info("Network connectivity verified")
+            return True
+        except Exception as e:
+            self.logger.error(f"Network verification failed: {str(e)}")
+            return False
+
+    async def start(self):
+        """Start application with robust error handling"""
+        try:
+            # Start Tor
+            self.logger.info("Starting Tor...")
+            await self.tor_manager.start()
+            self.logger.info(f"Tor started with onion address: {self.tor_manager.onion_address}")
+
+            # Initialize mesh network with retries
+            max_retries = 3
+            retry_delay = 2
+            last_error = None
+
+            for attempt in range(max_retries):
+                try:
+                    self.logger.info(f"Starting mesh network (attempt {attempt + 1}/{max_retries})...")
+                    await self.mesh_network.start()
+
+                    # Verify network is running
+                    if await self._verify_network():
+                        self.logger.info("Mesh network started and verified")
+                        break
+                    else:
+                        raise Exception("Network verification failed")
+
+                except Exception as e:
+                    last_error = e
+                    self.logger.warning(f"Attempt {attempt + 1} failed: {str(e)}")
+                    if attempt < max_retries - 1:
+                        await asyncio.sleep(retry_delay)
+                    else:
+                        raise Exception(f"Failed to start mesh network after {max_retries} attempts: {str(last_error)}")
+
+            # Start GUI
+            self.logger.info("Initializing GUI...")
+            self.window = ChatWindow(
+                self.mesh_network,
+                self.tor_manager,
+                self.crypto,
+                self.secure_memory
+            )
+
+            self.logger.info("Application fully started")
+            await self.window.run()
+
+        except Exception as e:
+            self.logger.error(f"Fatal error: {str(e)}")
+            await self.cleanup()
+            sys.exit(1)
+
+    async def cleanup(self):
+        """Cleanup with proper error handling"""
+        self.logger.info("Starting cleanup...")
+
+        cleanup_tasks = []
+
+        # Stop Tor
+        if hasattr(self, 'tor_manager'):
+            cleanup_tasks.append(self.tor_manager.stop())
+
+        # Stop mesh network
+        if hasattr(self, 'mesh_network'):
+            cleanup_tasks.append(self.mesh_network.stop())
+
+        # Wipe sensitive data
+        if hasattr(self, 'secure_memory'):
+            self.secure_memory.wipe_all()
+
+        # Wait for all cleanup tasks
+        if cleanup_tasks:
+            await asyncio.gather(*cleanup_tasks, return_exceptions=True)
+
+        self.logger.info("Cleanup completed")
+
+if __name__ == "__main__":
+    app = MeshChat()
+    try:
+        asyncio.run(app.start())
+    except KeyboardInterrupt:
+        app.logger.info("Received shutdown signal")
+        asyncio.run(app.cleanup())