wip: make work Services Status

Makefile

@@ -80,6 +80,10 @@ start-wg:
 	@echo "Starting WireGuard service..."
 	docker-compose up -d wireguard
 
+start-webui:
+	@echo "Starting WebUi service..."
+	docker-compose up -d webui
+
 # Maintenance commands
 clean:
 	@echo "Cleaning up containers and volumes..."

Personal Internet Cell – Project Wiki.md

@@ -438,7 +438,7 @@ python api/app.py
 python api/test_enhanced_api.py
 
 # Start frontend (if available)
-cd webui && npm install && npm run dev
+cd webui && bun install && npm run dev
 ```
 
 ### **Production Deployment**

README.md

@@ -345,7 +345,7 @@ python api/app.py
 python api/test_enhanced_api.py
 
 # Start frontend (if available)
-cd webui && npm install && npm run dev
+cd webui && bun install && npm run dev
 ```
 
 ### **Service Development**

api/Dockerfile

@@ -7,6 +7,13 @@ RUN apt-get update && apt-get install -y \
     wireguard-tools \
     iptables \
     curl \
+    ca-certificates \
+    gnupg \
+    lsb-release \
+    && curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg \
+    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null \
+    && apt-get update \
+    && apt-get install -y docker-ce-cli \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements first for better caching

api/app.py

@@ -102,9 +102,9 @@ CORS(app)
 app.config['DEVELOPMENT_MODE'] = True  # Set to True for development, False for production
 
 # Initialize enhanced components
-config_manager = ConfigManager()
+config_manager = ConfigManager(config_file='./config/cell_config.json', data_dir='./data')
 service_bus = ServiceBus()
-log_manager = LogManager()
+log_manager = LogManager(log_dir='./data/logs')
 
 # Initialize service loggers
 service_log_configs = {
@@ -150,17 +150,17 @@ def log_request(response):
 def clear_log_context(exc):
     request_context.set({})
 
-# Initialize managers
-network_manager = NetworkManager()
-wireguard_manager = WireGuardManager()
-peer_registry = PeerRegistry()
-email_manager = EmailManager()
-calendar_manager = CalendarManager()
-file_manager = FileManager()
-routing_manager = RoutingManager()
-cell_manager = CellManager()
-app.vault_manager = VaultManager()
-container_manager = ContainerManager()
+# Initialize managers with proper directories
+network_manager = NetworkManager(data_dir='./data', config_dir='./config')
+wireguard_manager = WireGuardManager(data_dir='./data', config_dir='./config')
+peer_registry = PeerRegistry(data_dir='./data', config_dir='./config')
+email_manager = EmailManager(data_dir='./data', config_dir='./config')
+calendar_manager = CalendarManager(data_dir='./data', config_dir='./config')
+file_manager = FileManager(data_dir='./data', config_dir='./config')
+routing_manager = RoutingManager(data_dir='./data', config_dir='./config')
+cell_manager = CellManager(data_dir='./data', config_dir='./config')
+app.vault_manager = VaultManager(data_dir='./data', config_dir='./config')
+container_manager = ContainerManager(data_dir='./data', config_dir='./config')
 
 # Register services with service bus
 service_bus.register_service('network', network_manager)
@@ -686,8 +686,8 @@ def test_network():
 def get_wireguard_keys():
     """Get WireGuard keys."""
     try:
-        keys = wireguard_manager.get_keys()
-        return jsonify(keys)
+        # For now, return empty keys - this would need to be implemented
+        return jsonify({"error": "Not implemented yet"}), 501
     except Exception as e:
         logger.error(f"Error getting WireGuard keys: {e}")
         return jsonify({"error": str(e)}), 500
@@ -697,7 +697,9 @@ def generate_peer_keys():
     """Generate peer keys."""
     try:
         data = request.get_json(silent=True)
-        result = wireguard_manager.generate_peer_keys(data)
+        if data is None or 'peer_name' not in data:
+            return jsonify({"error": "Missing peer_name"}), 400
+        result = wireguard_manager.generate_peer_keys(data['peer_name'])
         return jsonify(result)
     except Exception as e:
         logger.error(f"Error generating peer keys: {e}")
@@ -707,8 +709,8 @@ def generate_peer_keys():
 def get_wireguard_config():
     """Get WireGuard configuration."""
     try:
-        config = wireguard_manager.get_config()
-        return jsonify(config)
+        # For now, return empty config - this would need to be implemented
+        return jsonify({"error": "Not implemented yet"}), 501
     except Exception as e:
         logger.error(f"Error getting WireGuard config: {e}")
         return jsonify({"error": str(e)}), 500
@@ -717,7 +719,7 @@ def get_wireguard_config():
 def get_wireguard_peers():
     """Get WireGuard peers."""
     try:
-        peers = wireguard_manager.get_peers()
+        peers = wireguard_manager.get_wireguard_peers()
         return jsonify(peers)
     except Exception as e:
         logger.error(f"Error getting WireGuard peers: {e}")
@@ -728,8 +730,22 @@ def add_wireguard_peer():
     """Add WireGuard peer."""
     try:
         data = request.get_json(silent=True)
-        result = wireguard_manager.add_peer(data)
-        return jsonify(result)
+        if data is None:
+            return jsonify({"error": "No data provided"}), 400
+        
+        required_fields = ['name', 'public_key', 'allowed_ips']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({"error": f"Missing required field: {field}"}), 400
+        
+        result = wireguard_manager.add_wireguard_peer(
+            name=data['name'],
+            public_key=data['public_key'],
+            allowed_ips=data['allowed_ips'],
+            endpoint=data.get('endpoint', ''),
+            persistent_keepalive=data.get('persistent_keepalive', 25)
+        )
+        return jsonify({"success": result})
     except Exception as e:
         logger.error(f"Error adding WireGuard peer: {e}")
         return jsonify({"error": str(e)}), 500
@@ -739,8 +755,11 @@ def remove_wireguard_peer():
     """Remove WireGuard peer."""
     try:
         data = request.get_json(silent=True)
-        result = wireguard_manager.remove_peer(data)
-        return jsonify(result)
+        if data is None or 'name' not in data:
+            return jsonify({"error": "Missing peer name"}), 400
+        
+        result = wireguard_manager.remove_wireguard_peer(data['name'])
+        return jsonify({"success": result})
     except Exception as e:
         logger.error(f"Error removing WireGuard peer: {e}")
         return jsonify({"error": str(e)}), 500
@@ -772,8 +791,11 @@ def update_peer_ip():
     """Update peer IP."""
     try:
         data = request.get_json(silent=True)
-        result = wireguard_manager.update_peer_ip(data)
-        return jsonify(result)
+        if data is None or 'name' not in data or 'ip' not in data:
+            return jsonify({"error": "Missing peer name or IP"}), 400
+        
+        # For now, return not implemented - this would need to be implemented
+        return jsonify({"error": "Not implemented yet"}), 501
     except Exception as e:
         logger.error(f"Error updating peer IP: {e}")
         return jsonify({"error": str(e)}), 500
@@ -782,10 +804,11 @@ def update_peer_ip():
 def get_peer_config():
     try:
         data = request.get_json(silent=True)
-        if data is None:
-            return jsonify({"error": "No data provided"}), 400
-        result = wireguard_manager.get_peer_config(data)
-        return jsonify(result)
+        if data is None or 'name' not in data:
+            return jsonify({"error": "Missing peer name"}), 400
+        
+        # For now, return not implemented - this would need to be implemented
+        return jsonify({"error": "Not implemented yet"}), 501
     except Exception as e:
         logger.error(f"Error getting peer config: {e}")
         return jsonify({"error": str(e)}), 500
@@ -883,7 +906,8 @@ def update_peer_ip_registry(peer_name):
             except Exception as e:
                 logger.warning(f"RoutingManager update_peer_ip failed: {e}")
             try:
-                wireguard_manager.update_peer_ip(peer_name, new_ip)
+                # For now, skip WireGuard update - method not implemented
+                logger.warning(f"WireGuardManager update_peer_ip not implemented yet")
             except Exception as e:
                 logger.warning(f"WireGuardManager update_peer_ip failed: {e}")
             return jsonify({"message": f"IP update received for {peer_name}"})
@@ -912,7 +936,8 @@ def ip_update():
             except Exception as e:
                 logger.warning(f"RoutingManager update_peer_ip failed: {e}")
             try:
-                wireguard_manager.update_peer_ip(peer_name, new_ip)
+                # For now, skip WireGuard update - method not implemented
+                logger.warning(f"WireGuardManager update_peer_ip not implemented yet")
             except Exception as e:
                 logger.warning(f"WireGuardManager update_peer_ip failed: {e}")
             return jsonify({"message": f"IP update received for {peer_name}"})

api/calendar_manager.py

@@ -35,10 +35,11 @@ class CalendarManager(BaseServiceManager):
             is_docker = os.path.exists('/.dockerenv') or os.environ.get('DOCKER_CONTAINER') == 'true'
             
             if is_docker:
-                # Return positive status when running in Docker
+                # Check if calendar container is actually running
+                container_running = self._check_calendar_container_status()
                 status = {
-                    'running': True,
-                    'status': 'online',
+                    'running': container_running,
+                    'status': 'online' if container_running else 'offline',
                     'users_count': 0,
                     'calendars_count': 0,
                     'events_count': 0,
@@ -97,6 +98,16 @@ class CalendarManager(BaseServiceManager):
         except Exception:
             return False
 
+    def _check_calendar_container_status(self) -> bool:
+        """Check if calendar Docker container is running"""
+        try:
+            import docker
+            client = docker.from_env()
+            containers = client.containers.list(filters={'name': 'cell-radicale'})
+            return len(containers) > 0
+        except Exception:
+            return False
+
     def _test_service_connectivity(self) -> Dict[str, Any]:
         """Test calendar service connectivity"""
         try:

api/config_manager.py

@@ -1,383 +1,384 @@
-#!/usr/bin/env python3
-"""
-Configuration Manager for Personal Internet Cell
-Centralized configuration management for all services
-"""
-
-import os
-import json
-import yaml
-import shutil
-import hashlib
-from datetime import datetime
-from typing import Dict, List, Optional, Any
-from pathlib import Path
-import logging
-
-logger = logging.getLogger(__name__)
-
-class ConfigManager:
-    """Centralized configuration management for all services (unified config)"""
-    
-    def __init__(self, config_file: str = '/app/config/cell_config.json', data_dir: str = '/app/data'):
-        config_file = Path(config_file)
-        if config_file.is_dir():
-            config_file = config_file / 'cell_config.json'
-        print(f"[DEBUG] ConfigManager.__init__: config_file = {config_file}")
-        self.config_file = config_file
-        self.data_dir = Path(data_dir)
-        self.backup_dir = self.data_dir / 'config_backups'
-        self.secrets_file = self.config_file.parent / 'secrets.yaml'
-        self.backup_dir.mkdir(parents=True, exist_ok=True)
-        self.service_schemas = self._load_service_schemas()
-        self.configs = self._load_all_configs()
-
-    def _load_service_schemas(self) -> Dict[str, Dict]:
-        """Load configuration schemas for all services"""
-        return {
-            'network': {
-                'required': ['dns_port', 'dhcp_range', 'ntp_servers'],
-                'optional': ['dns_zones', 'dhcp_reservations'],
-                'types': {
-                    'dns_port': int,
-                    'dhcp_range': str,
-                    'ntp_servers': list
-                }
-            },
-            'wireguard': {
-                'required': ['port', 'private_key', 'address'],
-                'optional': ['peers', 'allowed_ips'],
-                'types': {
-                    'port': int,
-                    'private_key': str,
-                    'address': str
-                }
-            },
-            'email': {
-                'required': ['domain', 'smtp_port', 'imap_port'],
-                'optional': ['users', 'ssl_cert', 'ssl_key'],
-                'types': {
-                    'smtp_port': int,
-                    'imap_port': int,
-                    'domain': str
-                }
-            },
-            'calendar': {
-                'required': ['port', 'data_dir'],
-                'optional': ['users', 'calendars'],
-                'types': {
-                    'port': int,
-                    'data_dir': str
-                }
-            },
-            'files': {
-                'required': ['port', 'data_dir'],
-                'optional': ['users', 'quota'],
-                'types': {
-                    'port': int,
-                    'data_dir': str,
-                    'quota': int
-                }
-            },
-            'routing': {
-                'required': ['nat_enabled', 'firewall_enabled'],
-                'optional': ['nat_rules', 'firewall_rules', 'peer_routes'],
-                'types': {
-                    'nat_enabled': bool,
-                    'firewall_enabled': bool
-                }
-            },
-            'vault': {
-                'required': ['ca_configured', 'fernet_configured'],
-                'optional': ['certificates', 'trusted_keys'],
-                'types': {
-                    'ca_configured': bool,
-                    'fernet_configured': bool
-                }
-            }
-        }
-
-    def _load_all_configs(self) -> Dict[str, Dict]:
-        """Load all existing service configurations"""
-        if self.config_file.exists():
-            try:
-                with open(self.config_file, 'r') as f:
-                    return json.load(f)
-            except Exception as e:
-                logger.error(f"Error loading unified config: {e}")
-                return {}
-        return {}
-
-    def _save_all_configs(self):
-        """Save all service configurations to the unified config file"""
-        with open(self.config_file, 'w') as f:
-            json.dump(self.configs, f, indent=2)
-
-    def get_service_config(self, service: str) -> Dict[str, Any]:
-        """Get configuration for a specific service"""
-        if service not in self.service_schemas:
-            raise ValueError(f"Unknown service: {service}")
-        return self.configs.get(service, {})
-
-    def update_service_config(self, service: str, config: Dict[str, Any]) -> bool:
-        """Update configuration for a specific service"""
-        if service not in self.service_schemas:
-            raise ValueError(f"Unknown service: {service}")
-        try:
-            # Validate configuration
-            validation = self.validate_config(service, config)
-            if not validation['valid']:
-                logger.error(f"Invalid config for {service}: {validation['errors']}")
-                return False
-            
-            # Backup current config
-            self._backup_service_config(service)
-            
-            # Update configuration
-            self.configs[service] = config
-            self._save_all_configs()
-            
-            logger.info(f"Updated configuration for {service}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error updating config for {service}: {e}")
-            return False
-    
-    def validate_config(self, service: str, config: Dict[str, Any]) -> Dict[str, Any]:
-        """Validate configuration for a service"""
-        if service not in self.service_schemas:
-            return {
-                "valid": False,
-                "errors": [f"Unknown service: {service}"],
-                "warnings": []
-            }
-        
-        schema = self.service_schemas[service]
-        errors = []
-        warnings = []
-        
-        # Check required fields
-        for field in schema['required']:
-            if field not in config:
-                errors.append(f"Missing required field: {field}")
-            elif field in schema['types']:
-                expected_type = schema['types'][field]
-                if not isinstance(config[field], expected_type):
-                    errors.append(f"Field {field} must be of type {expected_type.__name__}")
-        
-        # Check optional fields
-        for field in schema['optional']:
-            if field in config and field in schema['types']:
-                expected_type = schema['types'][field]
-                if not isinstance(config[field], expected_type):
-                    warnings.append(f"Field {field} should be of type {expected_type.__name__}")
-        
-        return {
-            "valid": len(errors) == 0,
-            "errors": errors,
-            "warnings": warnings
-        }
-    
-    def backup_config(self) -> str:
-        """Create a backup of all configurations"""
-        try:
-            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-            backup_id = f"backup_{timestamp}"
-            backup_path = self.backup_dir / backup_id
-            
-            # Create backup directory
-            backup_path.mkdir(parents=True, exist_ok=True)
-            
-            # Copy all config files
-            shutil.copy2(self.config_file, backup_path / 'cell_config.json')
-            
-            # Copy secrets file if it exists
-            if self.secrets_file.exists():
-                shutil.copy2(self.secrets_file, backup_path / 'secrets.yaml')
-            
-            # Create backup manifest
-            manifest = {
-                "backup_id": backup_id,
-                "timestamp": datetime.now().isoformat(),
-                "services": list(self.service_schemas.keys()),
-                "files": [f.name for f in backup_path.iterdir()]
-            }
-            
-            with open(backup_path / 'manifest.json', 'w') as f:
-                json.dump(manifest, f, indent=2)
-            
-            logger.info(f"Created configuration backup: {backup_id}")
-            return backup_id
-            
-        except Exception as e:
-            logger.error(f"Error creating backup: {e}")
-            raise
-    
-    def restore_config(self, backup_id: str) -> bool:
-        """Restore configuration from backup"""
-        try:
-            backup_path = self.backup_dir / backup_id
-            if not backup_path.exists():
-                raise ValueError(f"Backup {backup_id} not found")
-            # Read manifest
-            manifest_file = backup_path / 'manifest.json'
-            if not manifest_file.exists():
-                raise ValueError(f"Backup manifest not found")
-            with open(manifest_file, 'r') as f:
-                manifest = json.load(f)
-            # Restore config files
-            config_backup = backup_path / 'cell_config.json'
-            if config_backup.exists():
-                shutil.copy2(config_backup, self.config_file)
-            # Restore secrets file if it exists
-            secrets_backup = backup_path / 'secrets.yaml'
-            if secrets_backup.exists():
-                shutil.copy2(secrets_backup, self.secrets_file)
-            # Reload configurations
-            self.configs = self._load_all_configs()
-            # Ensure all configs have required fields
-            for service, schema in self.service_schemas.items():
-                config = self.configs.get(service, {})
-                for field in schema['required']:
-                    if field not in config:
-                        # Set a default value based on type
-                        t = schema['types'][field]
-                        if t is int:
-                            config[field] = 0
-                        elif t is str:
-                            config[field] = ''
-                        elif t is list:
-                            config[field] = []
-                        elif t is bool:
-                            config[field] = False
-                self.configs[service] = config
-                # Write back to file
-                self._save_all_configs()
-            logger.info(f"Restored configuration from backup: {backup_id}")
-            return True
-        except Exception as e:
-            logger.error(f"Error restoring backup {backup_id}: {e}")
-            return False
-    
-    def list_backups(self) -> List[Dict[str, Any]]:
-        """List all available backups"""
-        backups = []
-        for backup_dir in self.backup_dir.iterdir():
-            if backup_dir.is_dir():
-                manifest_file = backup_dir / 'manifest.json'
-                if manifest_file.exists():
-                    try:
-                        with open(manifest_file, 'r') as f:
-                            manifest = json.load(f)
-                        backups.append(manifest)
-                    except Exception as e:
-                        logger.error(f"Error reading backup manifest {backup_dir.name}: {e}")
-        
-        return sorted(backups, key=lambda x: x['timestamp'], reverse=True)
-    
-    def delete_backup(self, backup_id: str) -> bool:
-        """Delete a backup"""
-        try:
-            backup_path = self.backup_dir / backup_id
-            if not backup_path.exists():
-                raise ValueError(f"Backup {backup_id} not found")
-            
-            shutil.rmtree(backup_path)
-            logger.info(f"Deleted backup: {backup_id}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error deleting backup {backup_id}: {e}")
-            return False
-    
-    def get_config_hash(self, service: str) -> str:
-        """Get hash of service configuration for change detection"""
-        config = self.get_service_config(service)
-        config_str = json.dumps(config, sort_keys=True)
-        return hashlib.sha256(config_str.encode()).hexdigest()
-    
-    def has_config_changed(self, service: str, previous_hash: str) -> bool:
-        """Check if configuration has changed"""
-        current_hash = self.get_config_hash(service)
-        return current_hash != previous_hash
-    
-    def export_config(self, format: str = 'json') -> str:
-        """Export all configurations in specified format"""
-        try:
-            if format == 'json':
-                return json.dumps(self.configs, indent=2)
-            elif format == 'yaml':
-                return yaml.dump(self.configs, default_flow_style=False)
-            else:
-                raise ValueError(f"Unsupported format: {format}")
-        except Exception as e:
-            logger.error(f"Error exporting config: {e}")
-            raise
-    
-    def import_config(self, config_data: str, format: str = 'json') -> bool:
-        """Import configurations from string"""
-        try:
-            if format == 'json':
-                configs = json.loads(config_data)
-            elif format == 'yaml':
-                configs = yaml.safe_load(config_data)
-            else:
-                raise ValueError(f"Unsupported format: {format}")
-            # Validate and update each service config
-            for service, config in configs.items():
-                if service in self.service_schemas:
-                    self.update_service_config(service, config)
-            # Ensure all configs have required fields
-            for service, schema in self.service_schemas.items():
-                config = self.get_service_config(service)
-                for field in schema['required']:
-                    if field not in config:
-                        t = schema['types'][field]
-                        if t is int:
-                            config[field] = 0
-                        elif t is str:
-                            config[field] = ''
-                        elif t is list:
-                            config[field] = []
-                        elif t is bool:
-                            config[field] = False
-                # Write back to file
-                self._save_all_configs()
-            logger.info("Imported configurations successfully")
-            return True
-        except Exception as e:
-            logger.error(f"Error importing config: {e}")
-            return False
-    
-    def _backup_service_config(self, service: str):
-        """Create backup of specific service config before update"""
-        # No-op for unified config, but keep for compatibility
-        pass
-    
-    def get_all_configs(self) -> Dict[str, Dict]:
-        """Get all service configurations"""
-        return self.configs.copy()
-    
-    def get_config_summary(self) -> Dict[str, Any]:
-        """Get summary of all configurations"""
-        summary = {
-            "total_services": len(self.service_schemas),
-            "configured_services": [],
-            "unconfigured_services": [],
-            "backup_count": len(self.list_backups()),
-            "last_backup": None
-        }
-        
-        backups = self.list_backups()
-        if backups:
-            summary["last_backup"] = backups[0]["timestamp"]
-        
-        for service in self.service_schemas.keys():
-            config = self.get_service_config(service)
-            if config and not config.get("error"):
-                summary["configured_services"].append(service)
-            else:
-                summary["unconfigured_services"].append(service)
-        
+#!/usr/bin/env python3
+"""
+Configuration Manager for Personal Internet Cell
+Centralized configuration management for all services
+"""
+
+import os
+import json
+import yaml
+import shutil
+import hashlib
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ConfigManager:
+    """Centralized configuration management for all services (unified config)"""
+    
+    def __init__(self, config_file: str = '/app/config/cell_config.json', data_dir: str = '/app/data'):
+        config_file = Path(config_file)
+        if config_file.is_dir():
+            config_file = config_file / 'cell_config.json'
+        print(f"[DEBUG] ConfigManager.__init__: config_file = {config_file}")
+        self.config_file = config_file
+        self.data_dir = Path(data_dir)
+        self.backup_dir = self.data_dir / 'config_backups'
+        self.secrets_file = self.config_file.parent / 'secrets.yaml'
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+        self.service_schemas = self._load_service_schemas()
+        self.configs = self._load_all_configs()
+
+    def _load_service_schemas(self) -> Dict[str, Dict]:
+        """Load configuration schemas for all services"""
+        return {
+            'network': {
+                'required': ['dns_port', 'dhcp_range', 'ntp_servers'],
+                'optional': ['dns_zones', 'dhcp_reservations'],
+                'types': {
+                    'dns_port': int,
+                    'dhcp_range': str,
+                    'ntp_servers': list
+                }
+            },
+            'wireguard': {
+                'required': ['port', 'private_key', 'address'],
+                'optional': ['peers', 'allowed_ips'],
+                'types': {
+                    'port': int,
+                    'private_key': str,
+                    'address': str
+                }
+            },
+            'email': {
+                'required': ['domain', 'smtp_port', 'imap_port'],
+                'optional': ['users', 'ssl_cert', 'ssl_key'],
+                'types': {
+                    'smtp_port': int,
+                    'imap_port': int,
+                    'domain': str
+                }
+            },
+            'calendar': {
+                'required': ['port', 'data_dir'],
+                'optional': ['users', 'calendars'],
+                'types': {
+                    'port': int,
+                    'data_dir': str
+                }
+            },
+            'files': {
+                'required': ['port', 'data_dir'],
+                'optional': ['users', 'quota'],
+                'types': {
+                    'port': int,
+                    'data_dir': str,
+                    'quota': int
+                }
+            },
+            'routing': {
+                'required': ['nat_enabled', 'firewall_enabled'],
+                'optional': ['nat_rules', 'firewall_rules', 'peer_routes'],
+                'types': {
+                    'nat_enabled': bool,
+                    'firewall_enabled': bool
+                }
+            },
+            'vault': {
+                'required': ['ca_configured', 'fernet_configured'],
+                'optional': ['certificates', 'trusted_keys'],
+                'types': {
+                    'ca_configured': bool,
+                    'fernet_configured': bool
+                }
+            }
+        }
+
+    def _load_all_configs(self) -> Dict[str, Dict]:
+        """Load all existing service configurations"""
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, 'r') as f:
+                    return json.load(f)
+            except Exception as e:
+                logger.error(f"Error loading unified config: {e}")
+                return {}
+        return {}
+
+    def _save_all_configs(self):
+        """Save all service configurations to the unified config file"""
+        with open(self.config_file, 'w') as f:
+            json.dump(self.configs, f, indent=2)
+
+    def get_service_config(self, service: str) -> Dict[str, Any]:
+        """Get configuration for a specific service"""
+        if service not in self.service_schemas:
+            raise ValueError(f"Unknown service: {service}")
+        return self.configs.get(service, {})
+
+    def update_service_config(self, service: str, config: Dict[str, Any]) -> bool:
+        """Update configuration for a specific service"""
+        if service not in self.service_schemas:
+            raise ValueError(f"Unknown service: {service}")
+        try:
+            # Validate configuration
+            validation = self.validate_config(service, config)
+            if not validation['valid']:
+                logger.error(f"Invalid config for {service}: {validation['errors']}")
+                return False
+            
+            # Backup current config
+            self._backup_service_config(service)
+            
+            # Update configuration
+            self.configs[service] = config
+            self._save_all_configs()
+            
+            logger.info(f"Updated configuration for {service}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error updating config for {service}: {e}")
+            return False
+    
+    def validate_config(self, service: str, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate configuration for a service"""
+        if service not in self.service_schemas:
+            return {
+                "valid": False,
+                "errors": [f"Unknown service: {service}"],
+                "warnings": []
+            }
+        
+        schema = self.service_schemas[service]
+        errors = []
+        warnings = []
+        
+        # Check required fields
+        for field in schema['required']:
+            if field not in config:
+                errors.append(f"Missing required field: {field}")
+            elif field in schema['types']:
+                expected_type = schema['types'][field]
+                if not isinstance(config[field], expected_type):
+                    errors.append(f"Field {field} must be of type {expected_type.__name__}")
+        
+        # Check optional fields
+        for field in schema['optional']:
+            if field in config and field in schema['types']:
+                expected_type = schema['types'][field]
+                if not isinstance(config[field], expected_type):
+                    warnings.append(f"Field {field} should be of type {expected_type.__name__}")
+        
+        return {
+            "valid": len(errors) == 0,
+            "errors": errors,
+            "warnings": warnings
+        }
+    
+    def backup_config(self) -> str:
+        """Create a backup of all configurations"""
+        try:
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            backup_id = f"backup_{timestamp}"
+            backup_path = self.backup_dir / backup_id
+            
+            # Create backup directory
+            backup_path.mkdir(parents=True, exist_ok=True)
+            
+            # Copy all config files
+            shutil.copy2(self.config_file, backup_path / 'cell_config.json')
+            
+            # Copy secrets file if it exists
+            if self.secrets_file.exists():
+                shutil.copy2(self.secrets_file, backup_path / 'secrets.yaml')
+            
+            # Create backup manifest
+            manifest = {
+                "backup_id": backup_id,
+                "timestamp": datetime.now().isoformat(),
+                "services": list(self.service_schemas.keys()),
+                "files": [f.name for f in backup_path.iterdir()]
+            }
+            
+            with open(backup_path / 'manifest.json', 'w') as f:
+                json.dump(manifest, f, indent=2)
+            
+            logger.info(f"Created configuration backup: {backup_id}")
+            return backup_id
+            
+        except Exception as e:
+            logger.error(f"Error creating backup: {e}")
+            raise
+    
+    def restore_config(self, backup_id: str) -> bool:
+        """Restore configuration from backup"""
+        try:
+            backup_path = self.backup_dir / backup_id
+            if not backup_path.exists():
+                raise ValueError(f"Backup {backup_id} not found")
+            # Read manifest
+            manifest_file = backup_path / 'manifest.json'
+            if not manifest_file.exists():
+                raise ValueError(f"Backup manifest not found")
+            with open(manifest_file, 'r') as f:
+                manifest = json.load(f)
+            # Restore config files
+            config_backup = backup_path / 'cell_config.json'
+            if config_backup.exists():
+                shutil.copy2(config_backup, self.config_file)
+            # Restore secrets file if it exists
+            secrets_backup = backup_path / 'secrets.yaml'
+            if secrets_backup.exists():
+                shutil.copy2(secrets_backup, self.secrets_file)
+            # Reload configurations
+            self.configs = self._load_all_configs()
+            # Ensure all configs have required fields
+            for service, schema in self.service_schemas.items():
+                config = self.configs.get(service, {})
+                for field in schema['required']:
+                    if field not in config:
+                        # Set a default value based on type
+                        t = schema['types'][field]
+                        if t is int:
+                            config[field] = 0
+                        elif t is str:
+                            config[field] = ''
+                        elif t is list:
+                            config[field] = []
+                        elif t is bool:
+                            config[field] = False
+                self.configs[service] = config
+            
+            # Write back to file
+            self._save_all_configs()
+            logger.info(f"Restored configuration from backup: {backup_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Error restoring backup {backup_id}: {e}")
+            return False
+    
+    def list_backups(self) -> List[Dict[str, Any]]:
+        """List all available backups"""
+        backups = []
+        for backup_dir in self.backup_dir.iterdir():
+            if backup_dir.is_dir():
+                manifest_file = backup_dir / 'manifest.json'
+                if manifest_file.exists():
+                    try:
+                        with open(manifest_file, 'r') as f:
+                            manifest = json.load(f)
+                        backups.append(manifest)
+                    except Exception as e:
+                        logger.error(f"Error reading backup manifest {backup_dir.name}: {e}")
+        
+        return sorted(backups, key=lambda x: x['timestamp'], reverse=True)
+    
+    def delete_backup(self, backup_id: str) -> bool:
+        """Delete a backup"""
+        try:
+            backup_path = self.backup_dir / backup_id
+            if not backup_path.exists():
+                raise ValueError(f"Backup {backup_id} not found")
+            
+            shutil.rmtree(backup_path)
+            logger.info(f"Deleted backup: {backup_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error deleting backup {backup_id}: {e}")
+            return False
+    
+    def get_config_hash(self, service: str) -> str:
+        """Get hash of service configuration for change detection"""
+        config = self.get_service_config(service)
+        config_str = json.dumps(config, sort_keys=True)
+        return hashlib.sha256(config_str.encode()).hexdigest()
+    
+    def has_config_changed(self, service: str, previous_hash: str) -> bool:
+        """Check if configuration has changed"""
+        current_hash = self.get_config_hash(service)
+        return current_hash != previous_hash
+    
+    def export_config(self, format: str = 'json') -> str:
+        """Export all configurations in specified format"""
+        try:
+            if format == 'json':
+                return json.dumps(self.configs, indent=2)
+            elif format == 'yaml':
+                return yaml.dump(self.configs, default_flow_style=False)
+            else:
+                raise ValueError(f"Unsupported format: {format}")
+        except Exception as e:
+            logger.error(f"Error exporting config: {e}")
+            raise
+    
+    def import_config(self, config_data: str, format: str = 'json') -> bool:
+        """Import configurations from string"""
+        try:
+            if format == 'json':
+                configs = json.loads(config_data)
+            elif format == 'yaml':
+                configs = yaml.safe_load(config_data)
+            else:
+                raise ValueError(f"Unsupported format: {format}")
+            # Validate and update each service config
+            for service, config in configs.items():
+                if service in self.service_schemas:
+                    self.update_service_config(service, config)
+            # Ensure all configs have required fields
+            for service, schema in self.service_schemas.items():
+                config = self.get_service_config(service)
+                for field in schema['required']:
+                    if field not in config:
+                        t = schema['types'][field]
+                        if t is int:
+                            config[field] = 0
+                        elif t is str:
+                            config[field] = ''
+                        elif t is list:
+                            config[field] = []
+                        elif t is bool:
+                            config[field] = False
+                # Write back to file
+                self._save_all_configs()
+            logger.info("Imported configurations successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Error importing config: {e}")
+            return False
+    
+    def _backup_service_config(self, service: str):
+        """Create backup of specific service config before update"""
+        # No-op for unified config, but keep for compatibility
+        pass
+    
+    def get_all_configs(self) -> Dict[str, Dict]:
+        """Get all service configurations"""
+        return self.configs.copy()
+    
+    def get_config_summary(self) -> Dict[str, Any]:
+        """Get summary of all configurations"""
+        summary = {
+            "total_services": len(self.service_schemas),
+            "configured_services": [],
+            "unconfigured_services": [],
+            "backup_count": len(self.list_backups()),
+            "last_backup": None
+        }
+        
+        backups = self.list_backups()
+        if backups:
+            summary["last_backup"] = backups[0]["timestamp"]
+        
+        for service in self.service_schemas.keys():
+            config = self.get_service_config(service)
+            if config and not config.get("error"):
+                summary["configured_services"].append(service)
+            else:
+                summary["unconfigured_services"].append(service)
+        
         return summary 

api/email_manager.py

@@ -35,12 +35,13 @@ class EmailManager(BaseServiceManager):
             is_docker = os.path.exists('/.dockerenv') or os.environ.get('DOCKER_CONTAINER') == 'true'
             
             if is_docker:
-                # Return positive status when running in Docker
+                # Check if email container is actually running
+                container_running = self._check_email_container_status()
                 status = {
-                    'running': True,
-                    'status': 'online',
-                    'smtp_running': True,
-                    'imap_running': True,
+                    'running': container_running,
+                    'status': 'online' if container_running else 'offline',
+                    'smtp_running': container_running,
+                    'imap_running': container_running,
                     'users_count': 0,
                     'domain': 'cell.local',
                     'timestamp': datetime.utcnow().isoformat()
@@ -106,6 +107,16 @@ class EmailManager(BaseServiceManager):
         except Exception:
             return False
 
+    def _check_email_container_status(self) -> bool:
+        """Check if email Docker container is running"""
+        try:
+            import docker
+            client = docker.from_env()
+            containers = client.containers.list(filters={'name': 'cell-mail'})
+            return len(containers) > 0
+        except Exception:
+            return False
+
     def _test_smtp_connectivity(self) -> Dict[str, Any]:
         """Test SMTP connectivity"""
         try:

api/file_manager.py

@@ -478,11 +478,12 @@ umask = 022
             is_docker = os.path.exists('/.dockerenv') or os.environ.get('DOCKER_CONTAINER') == 'true'
             
             if is_docker:
-                # Return positive status when running in Docker
+                # Check if file container is actually running
+                container_running = self._check_file_container_status()
                 status = {
-                    'running': True,
-                    'status': 'online',
-                    'webdav_status': {'running': True, 'port': 8080},
+                    'running': container_running,
+                    'status': 'online' if container_running else 'offline',
+                    'webdav_status': {'running': container_running, 'port': 8080},
                     'users_count': 0,
                     'total_storage_used': {'bytes': 0, 'human_readable': '0 B'},
                     'timestamp': datetime.utcnow().isoformat()
@@ -505,6 +506,16 @@ umask = 022
         except Exception as e:
             return self.handle_error(e, "get_status")
 
+    def _check_file_container_status(self) -> bool:
+        """Check if file Docker container is running"""
+        try:
+            import docker
+            client = docker.from_env()
+            containers = client.containers.list(filters={'name': 'cell-webdav'})
+            return len(containers) > 0
+        except Exception:
+            return False
+
     def test_connectivity(self) -> Dict[str, Any]:
         """Test file service connectivity"""
         try:

api/network_manager.py

@@ -408,47 +408,111 @@ class NetworkManager(BaseServiceManager):
             is_docker = os.path.exists('/.dockerenv') or os.environ.get('DOCKER_CONTAINER') == 'true'
             
             if is_docker:
-                # Return positive status when running in Docker
+                # Check if network containers are actually running
+                dns_running = self._check_dns_container_status()
+                dhcp_running = self._check_dhcp_container_status()
+                ntp_running = self._check_ntp_container_status()
+                all_running = dns_running and dhcp_running and ntp_running
+                
                 status = {
-                    'dns_running': True,
-                    'dhcp_running': True,
-                    'ntp_running': True,
-                    'running': True,
-                    'status': 'online',
+                    'dns_running': dns_running,
+                    'dhcp_running': dhcp_running,
+                    'ntp_running': ntp_running,
+                    'running': all_running,
+                    'status': 'online' if all_running else 'offline',
+                    'network': {
+                        'dns_running': dns_running,
+                        'dhcp_running': dhcp_running,
+                        'ntp_running': ntp_running,
+                        'running': all_running,
+                        'status': 'online' if all_running else 'offline'
+                    },
                     'timestamp': datetime.utcnow().isoformat()
                 }
             else:
                 # Check actual service status in production
+                dns_running = self._check_dns_status()
+                dhcp_running = self._check_dhcp_status()
+                ntp_running = self._check_ntp_status()
+                
                 status = {
-                    'dns_running': self._check_dns_status(),
-                    'dhcp_running': self._check_dhcp_status(),
-                    'ntp_running': self._check_ntp_status(),
+                    'dns_running': dns_running,
+                    'dhcp_running': dhcp_running,
+                    'ntp_running': ntp_running,
+                    'running': dns_running and dhcp_running and ntp_running,
+                    'status': 'online' if (dns_running and dhcp_running and ntp_running) else 'offline',
+                    'network': {
+                        'dns_running': dns_running,
+                        'dhcp_running': dhcp_running,
+                        'ntp_running': ntp_running,
+                        'running': dns_running and dhcp_running and ntp_running,
+                        'status': 'online' if (dns_running and dhcp_running and ntp_running) else 'offline'
+                    },
                     'timestamp': datetime.utcnow().isoformat()
                 }
-                
-                # Determine overall status
-                status['running'] = status['dns_running'] and status['dhcp_running'] and status['ntp_running']
-                status['status'] = 'online' if status['running'] else 'offline'
             
             return status
         except Exception as e:
             return self.handle_error(e, "get_status")
 
+    def _check_dns_container_status(self) -> bool:
+        """Check if DNS Docker container is running"""
+        try:
+            import docker
+            client = docker.from_env()
+            containers = client.containers.list(filters={'name': 'cell-dns'})
+            return len(containers) > 0
+        except Exception:
+            return False
+
+    def _check_dhcp_container_status(self) -> bool:
+        """Check if DHCP Docker container is running"""
+        try:
+            import docker
+            client = docker.from_env()
+            containers = client.containers.list(filters={'name': 'cell-dhcp'})
+            return len(containers) > 0
+        except Exception:
+            return False
+
+    def _check_ntp_container_status(self) -> bool:
+        """Check if NTP Docker container is running"""
+        try:
+            import docker
+            client = docker.from_env()
+            containers = client.containers.list(filters={'name': 'cell-ntp'})
+            return len(containers) > 0
+        except Exception:
+            return False
+
     def test_connectivity(self) -> Dict[str, Any]:
         """Test network service connectivity"""
         try:
+            dns_test = self.test_dns_resolution('google.com')
+            dhcp_test = self.test_dhcp_functionality()
+            ntp_test = self.test_ntp_functionality()
+            
             results = {
-                'dns_test': self.test_dns_resolution('google.com'),
-                'dhcp_test': self.test_dhcp_functionality(),
-                'ntp_test': self.test_ntp_functionality(),
+                'dns_test': dns_test,
+                'dhcp_test': dhcp_test,
+                'ntp_test': ntp_test,
                 'timestamp': datetime.utcnow().isoformat()
             }
             
             # Determine overall success
-            results['success'] = all(
+            success = all(
                 result.get('success', False) 
-                for result in [results['dns_test'], results['dhcp_test'], results['ntp_test']]
+                for result in [dns_test, dhcp_test, ntp_test]
             )
+            results['success'] = success
+            
+            # Add network key for compatibility
+            results['network'] = {
+                'dns_test': dns_test,
+                'dhcp_test': dhcp_test,
+                'ntp_test': ntp_test,
+                'success': success
+            }
             
             return results
         except Exception as e:

api/routing_manager.py

@@ -9,6 +9,7 @@ import json
 import subprocess
 import logging
 import ipaddress
+import time
 from datetime import datetime
 from typing import Dict, List, Optional, Tuple, Any
 import re
@@ -24,12 +25,19 @@ class RoutingManager(BaseServiceManager):
         self.routing_dir = os.path.join(config_dir, 'routing')
         self.rules_file = os.path.join(data_dir, 'routing', 'rules.json')
         
+        # Service state tracking
+        self._service_running = False
+        self._state_file = os.path.join(data_dir, 'routing', 'service_state.json')
+        
         # Ensure directories exist
         os.makedirs(self.routing_dir, exist_ok=True)
         os.makedirs(os.path.dirname(self.rules_file), exist_ok=True)
         
         # Initialize routing configuration
         self._ensure_config_exists()
+        
+        # Load service state
+        self._load_service_state()
     
     def _ensure_config_exists(self):
         """Ensure routing configuration exists"""
@@ -53,6 +61,33 @@ class RoutingManager(BaseServiceManager):
         
         logger.info("Routing rules initialized")
     
+    def _load_service_state(self):
+        """Load service state from file"""
+        try:
+            if os.path.exists(self._state_file):
+                with open(self._state_file, 'r') as f:
+                    state = json.load(f)
+                    self._service_running = state.get('running', False)
+            else:
+                # Default to running if no state file exists (for backward compatibility)
+                self._service_running = True
+                self._save_service_state()
+        except Exception as e:
+            logger.error(f"Failed to load service state: {e}")
+            self._service_running = True
+    
+    def _save_service_state(self):
+        """Save service state to file"""
+        try:
+            state = {
+                'running': self._service_running,
+                'timestamp': datetime.utcnow().isoformat()
+            }
+            with open(self._state_file, 'w') as f:
+                json.dump(state, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save service state: {e}")
+    
     def _validate_cidr(self, cidr):
         import ipaddress
         try:
@@ -485,9 +520,12 @@ class RoutingManager(BaseServiceManager):
             routing_status = self.get_routing_status()
             rules = self._load_rules()
             
+            # Check if routing service is actually running by testing basic functionality
+            is_running = self._is_routing_service_running()
+            
             status = {
-                'running': routing_status.get('running', False),
-                'status': 'online' if routing_status.get('running', False) else 'offline',
+                'running': is_running,
+                'status': 'online' if is_running else 'offline',
                 'routing_status': routing_status,
                 'nat_rules_count': len(rules.get('nat_rules', [])),
                 'peer_routes_count': len(rules.get('peer_routes', {})),
@@ -569,6 +607,13 @@ class RoutingManager(BaseServiceManager):
                     'message': f'iptables access failed: {result.stderr}',
                     'error': result.stderr
                 }
+        except FileNotFoundError:
+            # System tools not available (development environment)
+            return {
+                'success': True,
+                'message': 'iptables not available (development mode)',
+                'rules_count': 0
+            }
         except Exception as e:
             return {
                 'success': False,
@@ -596,6 +641,13 @@ class RoutingManager(BaseServiceManager):
                     'message': f'Network interfaces access failed: {result.stderr}',
                     'error': result.stderr
                 }
+        except FileNotFoundError:
+            # System tools not available (development environment)
+            return {
+                'success': True,
+                'message': 'Network tools not available (development mode)',
+                'interfaces_count': 0
+            }
         except Exception as e:
             return {
                 'success': False,
@@ -623,6 +675,13 @@ class RoutingManager(BaseServiceManager):
                     'message': f'Routing table access failed: {result.stderr}',
                     'error': result.stderr
                 }
+        except FileNotFoundError:
+            # System tools not available (development environment)
+            return {
+                'success': True,
+                'message': 'Routing tools not available (development mode)',
+                'routes_count': 0
+            }
         except Exception as e:
             return {
                 'success': False,
@@ -815,6 +874,19 @@ class RoutingManager(BaseServiceManager):
             
             return routes
             
+        except FileNotFoundError:
+            # System tools not available (development environment)
+            # Return mock routing table for development
+            return [
+                {
+                    'route': 'default via 192.168.1.1 dev en0',
+                    'parsed': {'destination': 'default', 'via': '192.168.1.1', 'dev': 'en0', 'metric': ''}
+                },
+                {
+                    'route': '10.0.0.0/24 dev wg0',
+                    'parsed': {'destination': '10.0.0.0/24', 'via': '', 'dev': 'wg0', 'metric': ''}
+                }
+            ]
         except Exception as e:
             logger.error(f"Failed to get routing table: {e}")
             return []
@@ -843,4 +915,102 @@ class RoutingManager(BaseServiceManager):
             
         except Exception as e:
             logger.error(f"Failed to parse route: {e}")
-            return {'destination': route_line, 'via': '', 'dev': '', 'metric': ''} 
+            return {'destination': route_line, 'via': '', 'dev': '', 'metric': ''}
+    
+    def _is_routing_service_running(self) -> bool:
+        """Check if routing service is actually running"""
+        # Use internal state tracking instead of system tool checks
+        return self._service_running
+    
+    def start(self) -> bool:
+        """Start routing service"""
+        try:
+            # Set internal state to running
+            self._service_running = True
+            self._save_service_state()
+            
+            # Try to enable IP forwarding (may fail in Docker without privileges)
+            try:
+                subprocess.run(['sysctl', '-w', 'net.ipv4.ip_forward=1'], 
+                              check=True, timeout=10)
+            except (subprocess.CalledProcessError, FileNotFoundError) as e:
+                logger.warning(f"Could not enable IP forwarding: {e}")
+                # Continue anyway - service is considered started
+            
+            # Load existing rules
+            rules = self._load_rules()
+            
+            # Apply all enabled rules (may fail in Docker without privileges)
+            try:
+                for rule in rules.get('nat_rules', []):
+                    if rule.get('enabled', True):
+                        self._apply_nat_rule(rule)
+                
+                for rule in rules.get('firewall_rules', []):
+                    if rule.get('enabled', True):
+                        self._apply_firewall_rule(rule)
+                
+                for route in rules.get('peer_routes', {}).values():
+                    if route.get('enabled', True):
+                        self._apply_peer_route(route)
+                
+                for exit_node in rules.get('exit_nodes', []):
+                    if exit_node.get('enabled', True):
+                        self._apply_exit_node(exit_node)
+            except Exception as e:
+                logger.warning(f"Could not apply routing rules: {e}")
+                # Continue anyway - service is considered started
+            
+            logger.info("Routing service started successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to start routing service: {e}")
+            self._service_running = False
+            self._save_service_state()
+            return False
+    
+    def stop(self) -> bool:
+        """Stop routing service"""
+        try:
+            # Set internal state to stopped
+            self._service_running = False
+            self._save_service_state()
+            
+            # Try to clear all iptables rules (may fail in Docker without privileges)
+            try:
+                subprocess.run(['iptables', '-t', 'nat', '-F'], 
+                              check=True, timeout=10)
+                subprocess.run(['iptables', '-F'], 
+                              check=True, timeout=10)
+            except (subprocess.CalledProcessError, FileNotFoundError) as e:
+                logger.warning(f"Could not clear iptables rules: {e}")
+                # Continue anyway - service is considered stopped
+            
+            # Try to disable IP forwarding (may fail in Docker without privileges)
+            try:
+                subprocess.run(['sysctl', '-w', 'net.ipv4.ip_forward=0'], 
+                              check=True, timeout=10)
+            except (subprocess.CalledProcessError, FileNotFoundError) as e:
+                logger.warning(f"Could not disable IP forwarding: {e}")
+                # Continue anyway - service is considered stopped
+            
+            logger.info("Routing service stopped successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to stop routing service: {e}")
+            # Even if system commands fail, we consider the service stopped
+            self._service_running = False
+            self._save_service_state()
+            return True  # Return True because the state is now stopped
+    
+    def restart(self) -> bool:
+        """Restart routing service"""
+        try:
+            self.stop()
+            time.sleep(1)  # Brief pause
+            return self.start()
+        except Exception as e:
+            logger.error(f"Failed to restart routing service: {e}")
+            return False 

api/service_bus.py

@@ -179,27 +179,40 @@ class ServiceBus:
     def orchestrate_service_start(self, service_name: str) -> bool:
         """Orchestrate starting a service with its dependencies"""
         try:
-            # Check dependencies
-            dependencies = self.service_dependencies.get(service_name, [])
-            for dep in dependencies:
-                if dep not in self.service_registry:
-                    logger.warning(f"Service {service_name} depends on {dep} which is not registered")
+            # Map service names to Docker container names
+            service_to_container = {
+                'wireguard': 'cell-wireguard',
+                'email': 'cell-mail',
+                'calendar': 'cell-radicale',
+                'files': 'cell-webdav',
+                'network': 'cell-dns',  # DNS is the main network service
+                'routing': None,  # Routing is a system service, not a container
+                'vault': None,  # Vault is part of API, not a separate container
+                'container': None  # Container manager doesn't have its own container
+            }
+            
+            container_name = service_to_container.get(service_name)
+            
+            if container_name is None:
+                # For services without containers (routing, vault, container), just call their start method
+                if hasattr(self.service_registry[service_name], 'start'):
+                    self.service_registry[service_name].start()
+                logger.info(f"Started service (no container): {service_name}")
+                return True
+            
+            # For services with containers, start the Docker container
+            if 'container' in self.service_registry:
+                container_manager = self.service_registry['container']
+                success = container_manager.start_container(container_name)
+                if success:
+                    logger.info(f"Started container {container_name} for service {service_name}")
+                    return True
+                else:
+                    logger.error(f"Failed to start container {container_name} for service {service_name}")
                     return False
-            
-            # Run pre-start hooks
-            if service_name in self.lifecycle_hooks and 'pre_start' in self.lifecycle_hooks[service_name]:
-                self.lifecycle_hooks[service_name]['pre_start']()
-            
-            # Start the service
-            if hasattr(self.service_registry[service_name], 'start'):
-                self.service_registry[service_name].start()
-            
-            # Run post-start hooks
-            if service_name in self.lifecycle_hooks and 'post_start' in self.lifecycle_hooks[service_name]:
-                self.lifecycle_hooks[service_name]['post_start']()
-            
-            logger.info(f"Orchestrated start of service: {service_name}")
-            return True
+            else:
+                logger.error("Container manager not available")
+                return False
             
         except Exception as e:
             logger.error(f"Error orchestrating start of {service_name}: {e}")
@@ -208,20 +221,40 @@ class ServiceBus:
     def orchestrate_service_stop(self, service_name: str) -> bool:
         """Orchestrate stopping a service"""
         try:
-            # Run pre-stop hooks
-            if service_name in self.lifecycle_hooks and 'pre_stop' in self.lifecycle_hooks[service_name]:
-                self.lifecycle_hooks[service_name]['pre_stop']()
+            # Map service names to Docker container names
+            service_to_container = {
+                'wireguard': 'cell-wireguard',
+                'email': 'cell-mail',
+                'calendar': 'cell-radicale',
+                'files': 'cell-webdav',
+                'network': 'cell-dns',  # DNS is the main network service
+                'routing': None,  # Routing is a system service, not a container
+                'vault': None,  # Vault is part of API, not a separate container
+                'container': None  # Container manager doesn't have its own container
+            }
             
-            # Stop the service
-            if hasattr(self.service_registry[service_name], 'stop'):
-                self.service_registry[service_name].stop()
+            container_name = service_to_container.get(service_name)
             
-            # Run post-stop hooks
-            if service_name in self.lifecycle_hooks and 'post_stop' in self.lifecycle_hooks[service_name]:
-                self.lifecycle_hooks[service_name]['post_stop']()
+            if container_name is None:
+                # For services without containers (routing, vault, container), just call their stop method
+                if hasattr(self.service_registry[service_name], 'stop'):
+                    self.service_registry[service_name].stop()
+                logger.info(f"Stopped service (no container): {service_name}")
+                return True
             
-            logger.info(f"Orchestrated stop of service: {service_name}")
-            return True
+            # For services with containers, stop the Docker container
+            if 'container' in self.service_registry:
+                container_manager = self.service_registry['container']
+                success = container_manager.stop_container(container_name)
+                if success:
+                    logger.info(f"Stopped container {container_name} for service {service_name}")
+                    return True
+                else:
+                    logger.error(f"Failed to stop container {container_name} for service {service_name}")
+                    return False
+            else:
+                logger.error("Container manager not available")
+                return False
             
         except Exception as e:
             logger.error(f"Error orchestrating stop of {service_name}: {e}")

api/wireguard_manager.py

@@ -34,13 +34,14 @@ class WireGuardManager(BaseServiceManager):
             is_docker = os.path.exists('/.dockerenv') or os.environ.get('DOCKER_CONTAINER') == 'true'
             
             if is_docker:
-                # Return positive status when running in Docker
+                # Check if WireGuard container is actually running
+                container_running = self._check_wireguard_container_status()
                 status = {
-                    'running': True,
-                    'status': 'online',
-                    'interface': 'wg0',
-                    'peers_count': 1,
-                    'total_traffic': {'bytes_sent': 1024, 'bytes_received': 2048},
+                    'running': container_running,
+                    'status': 'online' if container_running else 'offline',
+                    'interface': 'wg0' if container_running else 'unknown',
+                    'peers_count': len(self._get_configured_peers()) if container_running else 0,
+                    'total_traffic': self._get_traffic_stats() if container_running else {'bytes_sent': 0, 'bytes_received': 0},
                     'timestamp': datetime.utcnow().isoformat()
                 }
             else:
@@ -88,6 +89,16 @@ class WireGuardManager(BaseServiceManager):
         except Exception:
             return False
 
+    def _check_wireguard_container_status(self) -> bool:
+        """Check if WireGuard Docker container is running"""
+        try:
+            import docker
+            client = docker.from_env()
+            containers = client.containers.list(filters={'name': 'cell-wireguard'})
+            return len(containers) > 0
+        except Exception:
+            return False
+
     def _check_interface_status(self) -> bool:
         """Check if WireGuard interface is up"""
         try:

webui/README.md

@@ -35,7 +35,7 @@ A modern React-based web interface for managing your Personal Internet Cell.
 
 1. Install dependencies:
    ```bash
-   npm install
+   bun install
    ```
 
 2. Start the development server:

webui/src/pages/Dashboard.jsx

@@ -1,284 +1,312 @@
-import { useState, useEffect } from 'react';
-import { 
-  Server, 
-  Users, 
-  Shield, 
-  Mail, 
-  Calendar, 
-  FolderOpen, 
-  Wifi,
-  Activity,
-  CheckCircle,
-  XCircle,
-  AlertCircle
-} from 'lucide-react';
-import { cellAPI, servicesAPI } from '../services/api';
-
-function Dashboard({ isOnline }) {
-  const [cellStatus, setCellStatus] = useState(null);
-  const [servicesStatus, setServicesStatus] = useState(null);
-  const [isLoading, setIsLoading] = useState(true);
-
-  useEffect(() => {
-    const fetchData = async () => {
-      if (!isOnline) {
-        setIsLoading(false);
-        return;
-      }
-
-      try {
-        const [statusResponse, servicesResponse] = await Promise.all([
-          cellAPI.getStatus(),
-          servicesAPI.getAllStatus()
-        ]);
-        
-        setCellStatus(statusResponse.data);
-        setServicesStatus(servicesResponse.data);
-      } catch (error) {
-        console.error('Failed to fetch dashboard data:', error);
-      } finally {
-        setIsLoading(false);
-      }
-    };
-
-    fetchData();
-    const interval = setInterval(fetchData, 30000); // Refresh every 30 seconds
-
-    return () => clearInterval(interval);
-  }, [isOnline]);
-
-  const getStatusIcon = (status) => {
-    if (status === true || status?.status === 'online' || status?.running === true) {
-      return <CheckCircle className="h-5 w-5 text-success-500" />;
-    } else if (status === false || status?.status === 'offline' || status?.running === false) {
-      return <XCircle className="h-5 w-5 text-danger-500" />;
-    } else {
-      return <AlertCircle className="h-5 w-5 text-warning-500" />;
-    }
-  };
-
-  const getStatusText = (status) => {
-    if (status === true || status?.status === 'online' || status?.running === true) {
-      return 'Online';
-    } else if (status === false || status?.status === 'offline' || status?.running === false) {
-      return 'Offline';
-    } else {
-      return 'Unknown';
-    }
-  };
-
-  const getStatusColor = (status) => {
-    if (status === true || status?.status === 'online' || status?.running === true) {
-      return 'text-success-600';
-    } else if (status === false || status?.status === 'offline' || status?.running === false) {
-      return 'text-danger-600';
-    } else {
-      return 'text-warning-600';
-    }
-  };
-
-  if (isLoading) {
-    return (
-      <div className="flex items-center justify-center h-64">
-        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary-600"></div>
-      </div>
-    );
-  }
-
-  return (
-    <div>
-      <div className="mb-8">
-        <h1 className="text-2xl font-bold text-gray-900">Dashboard</h1>
-        <p className="mt-2 text-gray-600">
-          Overview of your Personal Internet Cell status and services
-        </p>
-      </div>
-
-      {/* Cell Status */}
-      {cellStatus && (
-        <div className="mb-8">
-          <h2 className="text-lg font-semibold text-gray-900 mb-4">Cell Status</h2>
-          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
-            <div className="card">
-              <div className="flex items-center">
-                <Server className="h-8 w-8 text-primary-500" />
-                <div className="ml-4">
-                  <p className="text-sm font-medium text-gray-500">Cell Name</p>
-                  <p className="text-lg font-semibold text-gray-900">{cellStatus.cell_name}</p>
-                </div>
-              </div>
-            </div>
-            
-            <div className="card">
-              <div className="flex items-center">
-                <Users className="h-8 w-8 text-primary-500" />
-                <div className="ml-4">
-                  <p className="text-sm font-medium text-gray-500">Peers</p>
-                  <p className="text-lg font-semibold text-gray-900">{cellStatus.peers_count}</p>
-                </div>
-              </div>
-            </div>
-            
-            <div className="card">
-              <div className="flex items-center">
-                <Activity className="h-8 w-8 text-primary-500" />
-                <div className="ml-4">
-                  <p className="text-sm font-medium text-gray-500">Uptime</p>
-                  <p className="text-lg font-semibold text-gray-900">
-                    {Math.floor((cellStatus.uptime || 0) / 3600)}h {Math.floor(((cellStatus.uptime || 0) % 3600) / 60)}m
-                  </p>
-                </div>
-              </div>
-            </div>
-            
-            <div className="card">
-              <div className="flex items-center">
-                <div className="h-8 w-8 rounded-full bg-primary-100 flex items-center justify-center">
-                  <div className="h-3 w-3 rounded-full bg-primary-600"></div>
-                </div>
-                <div className="ml-4">
-                  <p className="text-sm font-medium text-gray-500">Status</p>
-                  <p className="text-lg font-semibold text-gray-900">Active</p>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      )}
-
-      {/* Services Status */}
-      {servicesStatus && (
-        <div className="mb-8">
-          <h2 className="text-lg font-semibold text-gray-900 mb-4">Services Status</h2>
-          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
-            <div className="card">
-              <div className="flex items-center justify-between">
-                <div className="flex items-center">
-                  <Shield className="h-6 w-6 text-primary-500" />
-                  <span className="ml-3 text-sm font-medium text-gray-900">WireGuard</span>
-                </div>
-                <div className="flex items-center">
-                  {getStatusIcon(servicesStatus.wireguard)}
-                  <span className={`ml-2 text-sm font-medium ${getStatusColor(servicesStatus.wireguard)}`}>
-                    {getStatusText(servicesStatus.wireguard)}
-                  </span>
-                </div>
-              </div>
-            </div>
-
-            <div className="card">
-              <div className="flex items-center justify-between">
-                <div className="flex items-center">
-                  <Mail className="h-6 w-6 text-primary-500" />
-                  <span className="ml-3 text-sm font-medium text-gray-900">Email</span>
-                </div>
-                <div className="flex items-center">
-                  {getStatusIcon(servicesStatus.email)}
-                  <span className={`ml-2 text-sm font-medium ${getStatusColor(servicesStatus.email)}`}>
-                    {getStatusText(servicesStatus.email)}
-                  </span>
-                </div>
-              </div>
-            </div>
-
-            <div className="card">
-              <div className="flex items-center justify-between">
-                <div className="flex items-center">
-                  <Calendar className="h-6 w-6 text-primary-500" />
-                  <span className="ml-3 text-sm font-medium text-gray-900">Calendar</span>
-                </div>
-                <div className="flex items-center">
-                  {getStatusIcon(servicesStatus.calendar)}
-                  <span className={`ml-2 text-sm font-medium ${getStatusColor(servicesStatus.calendar)}`}>
-                    {getStatusText(servicesStatus.calendar)}
-                  </span>
-                </div>
-              </div>
-            </div>
-
-            <div className="card">
-              <div className="flex items-center justify-between">
-                <div className="flex items-center">
-                  <FolderOpen className="h-6 w-6 text-primary-500" />
-                  <span className="ml-3 text-sm font-medium text-gray-900">Files</span>
-                </div>
-                <div className="flex items-center">
-                  {getStatusIcon(servicesStatus.files)}
-                  <span className={`ml-2 text-sm font-medium ${getStatusColor(servicesStatus.files)}`}>
-                    {getStatusText(servicesStatus.files)}
-                  </span>
-                </div>
-              </div>
-            </div>
-
-            <div className="card">
-              <div className="flex items-center justify-between">
-                <div className="flex items-center">
-                  <Wifi className="h-6 w-6 text-primary-500" />
-                  <span className="ml-3 text-sm font-medium text-gray-900">Routing</span>
-                </div>
-                <div className="flex items-center">
-                  {getStatusIcon(servicesStatus.routing)}
-                  <span className={`ml-2 text-sm font-medium ${getStatusColor(servicesStatus.routing)}`}>
-                    {getStatusText(servicesStatus.routing)}
-                  </span>
-                </div>
-              </div>
-            </div>
-
-            <div className="card">
-              <div className="flex items-center justify-between">
-                <div className="flex items-center">
-                  <Server className="h-6 w-6 text-primary-500" />
-                  <span className="ml-3 text-sm font-medium text-gray-900">Network</span>
-                </div>
-                <div className="flex items-center">
-                  {getStatusIcon(servicesStatus.network)}
-                  <span className={`ml-2 text-sm font-medium ${getStatusColor(servicesStatus.network)}`}>
-                    {getStatusText(servicesStatus.network)}
-                  </span>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      )}
-
-      {/* Quick Actions */}
-      <div>
-        <h2 className="text-lg font-semibold text-gray-900 mb-4">Quick Actions</h2>
-        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
-          <button className="card hover:shadow-md transition-shadow cursor-pointer">
-            <div className="flex items-center">
-              <Users className="h-6 w-6 text-primary-500" />
-              <span className="ml-3 text-sm font-medium text-gray-900">Manage Peers</span>
-            </div>
-          </button>
-          
-          <button className="card hover:shadow-md transition-shadow cursor-pointer">
-            <div className="flex items-center">
-              <Shield className="h-6 w-6 text-primary-500" />
-              <span className="ml-3 text-sm font-medium text-gray-900">WireGuard Config</span>
-            </div>
-          </button>
-          
-          <button className="card hover:shadow-md transition-shadow cursor-pointer">
-            <div className="flex items-center">
-              <Wifi className="h-6 w-6 text-primary-500" />
-              <span className="ml-3 text-sm font-medium text-gray-900">Routing Rules</span>
-            </div>
-          </button>
-          
-          <button className="card hover:shadow-md transition-shadow cursor-pointer">
-            <div className="flex items-center">
-              <Activity className="h-6 w-6 text-primary-500" />
-              <span className="ml-3 text-sm font-medium text-gray-900">View Logs</span>
-            </div>
-          </button>
-        </div>
-      </div>
-    </div>
-  );
-}
-
+import { useState, useEffect } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { 
+  Server, 
+  Users, 
+  Shield, 
+  Mail, 
+  Calendar, 
+  FolderOpen, 
+  Wifi,
+  Activity,
+  CheckCircle,
+  XCircle,
+  AlertCircle,
+  Play,
+  Square,
+  RotateCcw
+} from 'lucide-react';
+import { cellAPI, servicesAPI } from '../services/api';
+
+function Dashboard({ isOnline }) {
+  const navigate = useNavigate();
+  const [cellStatus, setCellStatus] = useState(null);
+  const [servicesStatus, setServicesStatus] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [serviceControls, setServiceControls] = useState({});
+
+  useEffect(() => {
+    fetchData();
+    const interval = setInterval(fetchData, 30000); // Refresh every 30 seconds
+
+    return () => clearInterval(interval);
+  }, [isOnline]);
+
+  const getStatusIcon = (status) => {
+    if (status === true || status?.status === 'online' || status?.running === true) {
+      return <CheckCircle className="h-5 w-5 text-success-500" />;
+    } else if (status === false || status?.status === 'offline' || status?.running === false) {
+      return <XCircle className="h-5 w-5 text-danger-500" />;
+    } else {
+      return <AlertCircle className="h-5 w-5 text-warning-500" />;
+    }
+  };
+
+  const getStatusText = (status) => {
+    if (status === true || status?.status === 'online' || status?.running === true) {
+      return 'Online';
+    } else if (status === false || status?.status === 'offline' || status?.running === false) {
+      return 'Offline';
+    } else {
+      return 'Unknown';
+    }
+  };
+
+  const getStatusColor = (status) => {
+    if (status === true || status?.status === 'online' || status?.running === true) {
+      return 'text-success-600';
+    } else if (status === false || status?.status === 'offline' || status?.running === false) {
+      return 'text-danger-600';
+    } else {
+      return 'text-warning-600';
+    }
+  };
+
+  const handleServiceControl = async (serviceName, action) => {
+    if (!isOnline) return;
+    
+    setServiceControls(prev => ({ ...prev, [serviceName]: { ...prev[serviceName], [action]: 'loading' } }));
+    
+    try {
+      let response;
+      switch (action) {
+        case 'start':
+          response = await servicesAPI.startService(serviceName);
+          break;
+        case 'stop':
+          response = await servicesAPI.stopService(serviceName);
+          break;
+        case 'restart':
+          response = await servicesAPI.restartService(serviceName);
+          break;
+        default:
+          throw new Error('Invalid action');
+      }
+      
+      if (response.data.success || response.data.message) {
+        // Refresh status after successful control action
+        setTimeout(() => {
+          fetchData();
+        }, 1000);
+      }
+    } catch (error) {
+      console.error(`Failed to ${action} ${serviceName}:`, error);
+    } finally {
+      setServiceControls(prev => ({ ...prev, [serviceName]: { ...prev[serviceName], [action]: 'idle' } }));
+    }
+  };
+
+  const renderServiceCard = (serviceName, icon, displayName, status) => {
+    return (
+      <div className="card">
+        <div className="flex items-center justify-between">
+          <div className="flex items-center">
+            {icon}
+            <span className="ml-3 text-sm font-medium text-gray-900">{displayName}</span>
+          </div>
+          <div className="flex items-center space-x-2">
+            <div className="flex items-center">
+              {getStatusIcon(status)}
+              <span className={`ml-2 text-sm font-medium ${getStatusColor(status)}`}>
+                {getStatusText(status)}
+              </span>
+            </div>
+            <div className="flex space-x-1">
+              <button
+                onClick={() => handleServiceControl(serviceName, 'start')}
+                disabled={serviceControls[serviceName]?.start === 'loading' || status?.running}
+                className="p-1 text-green-600 hover:text-green-800 disabled:opacity-50 disabled:cursor-not-allowed"
+                title={`Start ${displayName} Service`}
+              >
+                <Play className="h-4 w-4" />
+              </button>
+              <button
+                onClick={() => handleServiceControl(serviceName, 'stop')}
+                disabled={serviceControls[serviceName]?.stop === 'loading' || !status?.running}
+                className="p-1 text-red-600 hover:text-red-800 disabled:opacity-50 disabled:cursor-not-allowed"
+                title={`Stop ${displayName} Service`}
+              >
+                <Square className="h-4 w-4" />
+              </button>
+              <button
+                onClick={() => handleServiceControl(serviceName, 'restart')}
+                disabled={serviceControls[serviceName]?.restart === 'loading'}
+                className="p-1 text-blue-600 hover:text-blue-800 disabled:opacity-50 disabled:cursor-not-allowed"
+                title={`Restart ${displayName} Service`}
+              >
+                <RotateCcw className="h-4 w-4" />
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    );
+  };
+
+  const fetchData = async () => {
+    if (!isOnline) {
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      const [statusResponse, servicesResponse] = await Promise.all([
+        cellAPI.getStatus(),
+        servicesAPI.getAllStatus()
+      ]);
+      
+      setCellStatus(statusResponse.data);
+      
+      // Transform services data to match expected structure
+      const servicesData = servicesResponse.data;
+      const transformedServices = {
+        wireguard: servicesData.wireguard || { running: false, status: 'offline' },
+        email: servicesData.email || { running: false, status: 'offline' },
+        calendar: servicesData.calendar || { running: false, status: 'offline' },
+        files: servicesData.files || { running: false, status: 'offline' },
+        routing: servicesData.routing || { running: false, status: 'offline' },
+        network: servicesData.network || { running: false, status: 'offline' }
+      };
+      
+      setServicesStatus(transformedServices);
+    } catch (error) {
+      console.error('Failed to fetch dashboard data:', error);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center h-64">
+        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary-600"></div>
+      </div>
+    );
+  }
+
+  return (
+    <div>
+      <div className="mb-8">
+        <h1 className="text-2xl font-bold text-gray-900">Dashboard</h1>
+        <p className="mt-2 text-gray-600">
+          Overview of your Personal Internet Cell status and services
+        </p>
+      </div>
+
+      {/* Cell Status */}
+      {cellStatus && (
+        <div className="mb-8">
+          <h2 className="text-lg font-semibold text-gray-900 mb-4">Cell Status</h2>
+          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
+            <div className="card">
+              <div className="flex items-center">
+                <Server className="h-8 w-8 text-primary-500" />
+                <div className="ml-4">
+                  <p className="text-sm font-medium text-gray-500">Cell Name</p>
+                  <p className="text-lg font-semibold text-gray-900">{cellStatus.cell_name}</p>
+                </div>
+              </div>
+            </div>
+            
+            <div className="card">
+              <div className="flex items-center">
+                <Users className="h-8 w-8 text-primary-500" />
+                <div className="ml-4">
+                  <p className="text-sm font-medium text-gray-500">Peers</p>
+                  <p className="text-lg font-semibold text-gray-900">{cellStatus.peers_count}</p>
+                </div>
+              </div>
+            </div>
+            
+            <div className="card">
+              <div className="flex items-center">
+                <Activity className="h-8 w-8 text-primary-500" />
+                <div className="ml-4">
+                  <p className="text-sm font-medium text-gray-500">Uptime</p>
+                  <p className="text-lg font-semibold text-gray-900">
+                    {Math.floor((cellStatus.uptime || 0) / 3600)}h {Math.floor(((cellStatus.uptime || 0) % 3600) / 60)}m
+                  </p>
+                </div>
+              </div>
+            </div>
+            
+            <div className="card">
+              <div className="flex items-center">
+                <div className="h-8 w-8 rounded-full bg-primary-100 flex items-center justify-center">
+                  <div className="h-3 w-3 rounded-full bg-primary-600"></div>
+                </div>
+                <div className="ml-4">
+                  <p className="text-sm font-medium text-gray-500">Status</p>
+                  <p className="text-lg font-semibold text-gray-900">Active</p>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Services Status */}
+      {servicesStatus && (
+        <div className="mb-8">
+          <h2 className="text-lg font-semibold text-gray-900 mb-4">Services Status</h2>
+          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+            {renderServiceCard('wireguard', <Shield className="h-6 w-6 text-primary-500" />, 'WireGuard', servicesStatus.wireguard)}
+            {renderServiceCard('email', <Mail className="h-6 w-6 text-primary-500" />, 'Email', servicesStatus.email)}
+            {renderServiceCard('calendar', <Calendar className="h-6 w-6 text-primary-500" />, 'Calendar', servicesStatus.calendar)}
+            {renderServiceCard('files', <FolderOpen className="h-6 w-6 text-primary-500" />, 'Files', servicesStatus.files)}
+            {renderServiceCard('routing', <Wifi className="h-6 w-6 text-primary-500" />, 'Routing', servicesStatus.routing)}
+            {renderServiceCard('network', <Server className="h-6 w-6 text-primary-500" />, 'Network', servicesStatus.network)}
+          </div>
+        </div>
+      )}
+
+      {/* Quick Actions */}
+      <div>
+        <h2 className="text-lg font-semibold text-gray-900 mb-4">Quick Actions</h2>
+        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
+          <button 
+            onClick={() => navigate('/peers')}
+            className="card hover:shadow-md transition-shadow cursor-pointer"
+          >
+            <div className="flex items-center">
+              <Users className="h-6 w-6 text-primary-500" />
+              <span className="ml-3 text-sm font-medium text-gray-900">Manage Peers</span>
+            </div>
+          </button>
+          
+          <button 
+            onClick={() => navigate('/wireguard')}
+            className="card hover:shadow-md transition-shadow cursor-pointer"
+          >
+            <div className="flex items-center">
+              <Shield className="h-6 w-6 text-primary-500" />
+              <span className="ml-3 text-sm font-medium text-gray-900">WireGuard Config</span>
+            </div>
+          </button>
+          
+          <button 
+            onClick={() => navigate('/routing')}
+            className="card hover:shadow-md transition-shadow cursor-pointer"
+          >
+            <div className="flex items-center">
+              <Wifi className="h-6 w-6 text-primary-500" />
+              <span className="ml-3 text-sm font-medium text-gray-900">Routing Rules</span>
+            </div>
+          </button>
+          
+          <button 
+            onClick={() => navigate('/logs')}
+            className="card hover:shadow-md transition-shadow cursor-pointer"
+          >
+            <div className="flex items-center">
+              <Activity className="h-6 w-6 text-primary-500" />
+              <span className="ml-3 text-sm font-medium text-gray-900">View Logs</span>
+            </div>
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+
 export default Dashboard; 

webui/src/services/api.js

@@ -1,205 +1,208 @@
-import axios from 'axios';
-
-// Create axios instance with base configuration
-const api = axios.create({
-  baseURL: import.meta.env.VITE_API_URL || 'http://localhost:3000',
-  timeout: 10000,
-  headers: {
-    'Content-Type': 'application/json',
-  },
-});
-
-// Request interceptor for logging
-api.interceptors.request.use(
-  (config) => {
-    console.log(`API Request: ${config.method?.toUpperCase()} ${config.url}`);
-    return config;
-  },
-  (error) => {
-    console.error('API Request Error:', error);
-    return Promise.reject(error);
-  }
-);
-
-// Response interceptor for error handling
-api.interceptors.response.use(
-  (response) => {
-    return response;
-  },
-  (error) => {
-    console.error('API Response Error:', error.response?.data || error.message);
-    return Promise.reject(error);
-  }
-);
-
-// Cell Status API
-export const cellAPI = {
-  getStatus: () => api.get('/api/status'),
-  getConfig: () => api.get('/api/config'),
-  updateConfig: (config) => api.put('/api/config', config),
-};
-
-// Network Services API
-export const networkAPI = {
-  getDNSRecords: () => api.get('/api/dns/records'),
-  addDNSRecord: (record) => api.post('/api/dns/records', record),
-  removeDNSRecord: (record) => api.delete('/api/dns/records', { data: record }),
-  getDHCPLeases: () => api.get('/api/dhcp/leases'),
-  addDHCPReservation: (reservation) => api.post('/api/dhcp/reservations', reservation),
-  removeDHCPReservation: (reservation) => api.delete('/api/dhcp/reservations', { data: reservation }),
-  getNTPStatus: () => api.get('/api/ntp/status'),
-  testNetwork: (data) => api.post('/api/network/test', data),
-};
-
-// WireGuard API
-export const wireguardAPI = {
-  getKeys: () => api.get('/api/wireguard/keys'),
-  generatePeerKeys: (data) => api.post('/api/wireguard/keys/peer', data),
-  getConfig: () => api.get('/api/wireguard/config'),
-  getPeers: () => api.get('/api/wireguard/peers'),
-  addPeer: (peer) => api.post('/api/wireguard/peers', peer),
-  removePeer: (peer) => api.delete('/api/wireguard/peers', { data: peer }),
-  getStatus: () => api.get('/api/wireguard/status'),
-  testConnectivity: (data) => api.post('/api/wireguard/connectivity', data),
-  updatePeerIP: (data) => api.put('/api/wireguard/peers/ip', data),
-  getPeerConfig: (data) => api.post('/api/wireguard/peers/config', data),
-};
-
-// Peer Registry API
-export const peerAPI = {
-  getPeers: () => api.get('/api/peers'),
-  addPeer: (peer) => api.post('/api/peers', peer),
-  removePeer: (peerName) => api.delete(`/api/peers/${peerName}`),
-  registerPeer: (data) => api.post('/api/peers/register', data),
-  unregisterPeer: (peerName) => api.delete(`/api/peers/${peerName}/unregister`),
-  updatePeerIP: (peerName, data) => api.put(`/api/peers/${peerName}/update-ip`, data),
-};
-
-// Email Services API
-export const emailAPI = {
-  getUsers: () => api.get('/api/email/users'),
-  createUser: (user) => api.post('/api/email/users', user),
-  deleteUser: (username) => api.delete(`/api/email/users/${username}`),
-  getStatus: () => api.get('/api/email/status'),
-  testConnectivity: () => api.get('/api/email/connectivity'),
-  sendEmail: (data) => api.post('/api/email/send', data),
-  getMailboxInfo: (username) => api.get(`/api/email/mailbox/${username}`),
-};
-
-// Calendar Services API
-export const calendarAPI = {
-  getUsers: () => api.get('/api/calendar/users'),
-  createUser: (user) => api.post('/api/calendar/users', user),
-  deleteUser: (username) => api.delete(`/api/calendar/users/${username}`),
-  createCalendar: (data) => api.post('/api/calendar/calendars', data),
-  addEvent: (data) => api.post('/api/calendar/events', data),
-  getEvents: (username, calendarName, params) => 
-    api.get(`/api/calendar/events/${username}/${calendarName}`, { params }),
-  getStatus: () => api.get('/api/calendar/status'),
-  testConnectivity: () => api.get('/api/calendar/connectivity'),
-};
-
-// File Services API
-export const fileAPI = {
-  getUsers: () => api.get('/api/files/users'),
-  createUser: (user) => api.post('/api/files/users', user),
-  deleteUser: (username) => api.delete(`/api/files/users/${username}`),
-  createFolder: (data) => api.post('/api/files/folders', data),
-  deleteFolder: (username, folderPath) => api.delete(`/api/files/folders/${username}/${folderPath}`),
-  uploadFile: (username, file, path) => {
-    const formData = new FormData();
-    formData.append('file', file);
-    formData.append('path', path);
-    return api.post(`/api/files/upload/${username}`, formData, {
-      headers: { 'Content-Type': 'multipart/form-data' },
-    });
-  },
-  downloadFile: (username, filePath) => api.get(`/api/files/download/${username}/${filePath}`),
-  deleteFile: (username, filePath) => api.delete(`/api/files/delete/${username}/${filePath}`),
-  listFiles: (username, folder = '') => api.get(`/api/files/list/${username}`, { params: { folder } }),
-  getStatus: () => api.get('/api/files/status'),
-  testConnectivity: () => api.get('/api/files/connectivity'),
-};
-
-// Routing API
-export const routingAPI = {
-  getStatus: () => api.get('/api/routing/status'),
-  // NAT
-  getNatRules: () => api.get('/api/routing/nat'),
-  addNatRule: (rule) => api.post('/api/routing/nat', rule),
-  deleteNatRule: (ruleId) => api.delete(`/api/routing/nat/${ruleId}`),
-  // Peer Routes
-  getPeerRoutes: () => api.get('/api/routing/peers'),
-  addPeerRoute: (route) => api.post('/api/routing/peers', route),
-  deletePeerRoute: (peerName) => api.delete(`/api/routing/peers/${peerName}`),
-  // Firewall
-  getFirewallRules: () => api.get('/api/routing/firewall'),
-  addFirewallRule: (rule) => api.post('/api/routing/firewall', rule),
-  deleteFirewallRule: (ruleId) => api.delete(`/api/routing/firewall/${ruleId}`),
-  // Other
-  addExitNode: (node) => api.post('/api/routing/exit-nodes', node),
-  addBridgeRoute: (route) => api.post('/api/routing/bridge', route),
-  addSplitRoute: (route) => api.post('/api/routing/split', route),
-  testConnectivity: (data) => api.post('/api/routing/connectivity', data),
-  getLogs: (lines = 50) => api.get('/api/routing/logs', { params: { lines } }),
-};
-
-// Vault & Trust API
-export const vaultAPI = {
-  getStatus: () => api.get('/api/vault/status'),
-  getCertificates: () => api.get('/api/vault/certificates'),
-  generateCertificate: (data) => api.post('/api/vault/certificates', data),
-  revokeCertificate: (commonName) => api.delete(`/api/vault/certificates/${commonName}`),
-  getCACertificate: () => api.get('/api/vault/ca/certificate'),
-  getAgePublicKey: () => api.get('/api/vault/age/public-key'),
-  getTrustedKeys: () => api.get('/api/vault/trust/keys'),
-  addTrustedKey: (data) => api.post('/api/vault/trust/keys', data),
-  removeTrustedKey: (name) => api.delete(`/api/vault/trust/keys/${name}`),
-  verifyTrustChain: (data) => api.post('/api/vault/trust/verify', data),
-  getTrustChains: () => api.get('/api/vault/trust/chains'),
-  // Secrets management
-  listSecrets: () => api.get('/api/vault/secrets'),
-  storeSecret: (name, value) => api.post('/api/vault/secrets', { name, value }),
-  getSecret: (name) => api.get(`/api/vault/secrets/${name}`),
-  deleteSecret: (name) => api.delete(`/api/vault/secrets/${name}`),
-};
-
-// Services API
-export const servicesAPI = {
-  getAllStatus: () => api.get('/api/services/status'),
-  testAllConnectivity: () => api.get('/api/services/connectivity'),
-};
-
-// Health check
-export const healthAPI = {
-  check: () => api.get('/health'),
-};
-
-// Monitoring API
-export const monitoringAPI = {
-  getBackendLogs: (lines = 100) => api.get('/api/logs', { params: { lines } }),
-  getHealthHistory: () => api.get('/api/health/history'),
-};
-
-// Container Management API
-export const containerAPI = {
-  // Containers
-  listContainers: () => api.get('/api/containers'),
-  startContainer: (name) => api.post(`/api/containers/${name}/start`),
-  stopContainer: (name) => api.post(`/api/containers/${name}/stop`),
-  restartContainer: (name) => api.post(`/api/containers/${name}/restart`),
-  getContainerLogs: (name, tail = 100) => api.get(`/api/containers/${name}/logs`, { params: { tail } }),
-  getContainerStats: (name) => api.get(`/api/containers/${name}/stats`),
-  createContainer: (data) => api.post('/api/containers', data), // data may include 'secrets' array
-  removeContainer: (name, force = false) => api.delete(`/api/containers/${name}`, { params: { force } }),
-  // Images
-  listImages: () => api.get('/api/images'),
-  pullImage: (image) => api.post('/api/images/pull', { image }),
-  removeImage: (image, force = false) => api.delete(`/api/images/${image}`, { params: { force } }),
-  // Volumes
-  listVolumes: () => api.get('/api/volumes'),
-  createVolume: (name) => api.post('/api/volumes', { name }),
-  removeVolume: (name, force = false) => api.delete(`/api/volumes/${name}`, { params: { force } }),
-};
-
+import axios from 'axios';
+
+// Create axios instance with base configuration
+const api = axios.create({
+  baseURL: import.meta.env.VITE_API_URL || 'http://localhost:3000',
+  timeout: 10000,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+// Request interceptor for logging
+api.interceptors.request.use(
+  (config) => {
+    console.log(`API Request: ${config.method?.toUpperCase()} ${config.url}`);
+    return config;
+  },
+  (error) => {
+    console.error('API Request Error:', error);
+    return Promise.reject(error);
+  }
+);
+
+// Response interceptor for error handling
+api.interceptors.response.use(
+  (response) => {
+    return response;
+  },
+  (error) => {
+    console.error('API Response Error:', error.response?.data || error.message);
+    return Promise.reject(error);
+  }
+);
+
+// Cell Status API
+export const cellAPI = {
+  getStatus: () => api.get('/api/status'),
+  getConfig: () => api.get('/api/config'),
+  updateConfig: (config) => api.put('/api/config', config),
+};
+
+// Network Services API
+export const networkAPI = {
+  getDNSRecords: () => api.get('/api/dns/records'),
+  addDNSRecord: (record) => api.post('/api/dns/records', record),
+  removeDNSRecord: (record) => api.delete('/api/dns/records', { data: record }),
+  getDHCPLeases: () => api.get('/api/dhcp/leases'),
+  addDHCPReservation: (reservation) => api.post('/api/dhcp/reservations', reservation),
+  removeDHCPReservation: (reservation) => api.delete('/api/dhcp/reservations', { data: reservation }),
+  getNTPStatus: () => api.get('/api/ntp/status'),
+  testNetwork: (data) => api.post('/api/network/test', data),
+};
+
+// WireGuard API
+export const wireguardAPI = {
+  getKeys: () => api.get('/api/wireguard/keys'),
+  generatePeerKeys: (data) => api.post('/api/wireguard/keys/peer', data),
+  getConfig: () => api.get('/api/wireguard/config'),
+  getPeers: () => api.get('/api/wireguard/peers'),
+  addPeer: (peer) => api.post('/api/wireguard/peers', peer),
+  removePeer: (peer) => api.delete('/api/wireguard/peers', { data: peer }),
+  getStatus: () => api.get('/api/wireguard/status'),
+  testConnectivity: (data) => api.post('/api/wireguard/connectivity', data),
+  updatePeerIP: (data) => api.put('/api/wireguard/peers/ip', data),
+  getPeerConfig: (data) => api.post('/api/wireguard/peers/config', data),
+};
+
+// Peer Registry API
+export const peerAPI = {
+  getPeers: () => api.get('/api/peers'),
+  addPeer: (peer) => api.post('/api/peers', peer),
+  removePeer: (peerName) => api.delete(`/api/peers/${peerName}`),
+  registerPeer: (data) => api.post('/api/peers/register', data),
+  unregisterPeer: (peerName) => api.delete(`/api/peers/${peerName}/unregister`),
+  updatePeerIP: (peerName, data) => api.put(`/api/peers/${peerName}/update-ip`, data),
+};
+
+// Email Services API
+export const emailAPI = {
+  getUsers: () => api.get('/api/email/users'),
+  createUser: (user) => api.post('/api/email/users', user),
+  deleteUser: (username) => api.delete(`/api/email/users/${username}`),
+  getStatus: () => api.get('/api/email/status'),
+  testConnectivity: () => api.get('/api/email/connectivity'),
+  sendEmail: (data) => api.post('/api/email/send', data),
+  getMailboxInfo: (username) => api.get(`/api/email/mailbox/${username}`),
+};
+
+// Calendar Services API
+export const calendarAPI = {
+  getUsers: () => api.get('/api/calendar/users'),
+  createUser: (user) => api.post('/api/calendar/users', user),
+  deleteUser: (username) => api.delete(`/api/calendar/users/${username}`),
+  createCalendar: (data) => api.post('/api/calendar/calendars', data),
+  addEvent: (data) => api.post('/api/calendar/events', data),
+  getEvents: (username, calendarName, params) => 
+    api.get(`/api/calendar/events/${username}/${calendarName}`, { params }),
+  getStatus: () => api.get('/api/calendar/status'),
+  testConnectivity: () => api.get('/api/calendar/connectivity'),
+};
+
+// File Services API
+export const fileAPI = {
+  getUsers: () => api.get('/api/files/users'),
+  createUser: (user) => api.post('/api/files/users', user),
+  deleteUser: (username) => api.delete(`/api/files/users/${username}`),
+  createFolder: (data) => api.post('/api/files/folders', data),
+  deleteFolder: (username, folderPath) => api.delete(`/api/files/folders/${username}/${folderPath}`),
+  uploadFile: (username, file, path) => {
+    const formData = new FormData();
+    formData.append('file', file);
+    formData.append('path', path);
+    return api.post(`/api/files/upload/${username}`, formData, {
+      headers: { 'Content-Type': 'multipart/form-data' },
+    });
+  },
+  downloadFile: (username, filePath) => api.get(`/api/files/download/${username}/${filePath}`),
+  deleteFile: (username, filePath) => api.delete(`/api/files/delete/${username}/${filePath}`),
+  listFiles: (username, folder = '') => api.get(`/api/files/list/${username}`, { params: { folder } }),
+  getStatus: () => api.get('/api/files/status'),
+  testConnectivity: () => api.get('/api/files/connectivity'),
+};
+
+// Routing API
+export const routingAPI = {
+  getStatus: () => api.get('/api/routing/status'),
+  // NAT
+  getNatRules: () => api.get('/api/routing/nat'),
+  addNatRule: (rule) => api.post('/api/routing/nat', rule),
+  deleteNatRule: (ruleId) => api.delete(`/api/routing/nat/${ruleId}`),
+  // Peer Routes
+  getPeerRoutes: () => api.get('/api/routing/peers'),
+  addPeerRoute: (route) => api.post('/api/routing/peers', route),
+  deletePeerRoute: (peerName) => api.delete(`/api/routing/peers/${peerName}`),
+  // Firewall
+  getFirewallRules: () => api.get('/api/routing/firewall'),
+  addFirewallRule: (rule) => api.post('/api/routing/firewall', rule),
+  deleteFirewallRule: (ruleId) => api.delete(`/api/routing/firewall/${ruleId}`),
+  // Other
+  addExitNode: (node) => api.post('/api/routing/exit-nodes', node),
+  addBridgeRoute: (route) => api.post('/api/routing/bridge', route),
+  addSplitRoute: (route) => api.post('/api/routing/split', route),
+  testConnectivity: (data) => api.post('/api/routing/connectivity', data),
+  getLogs: (lines = 50) => api.get('/api/routing/logs', { params: { lines } }),
+};
+
+// Vault & Trust API
+export const vaultAPI = {
+  getStatus: () => api.get('/api/vault/status'),
+  getCertificates: () => api.get('/api/vault/certificates'),
+  generateCertificate: (data) => api.post('/api/vault/certificates', data),
+  revokeCertificate: (commonName) => api.delete(`/api/vault/certificates/${commonName}`),
+  getCACertificate: () => api.get('/api/vault/ca/certificate'),
+  getAgePublicKey: () => api.get('/api/vault/age/public-key'),
+  getTrustedKeys: () => api.get('/api/vault/trust/keys'),
+  addTrustedKey: (data) => api.post('/api/vault/trust/keys', data),
+  removeTrustedKey: (name) => api.delete(`/api/vault/trust/keys/${name}`),
+  verifyTrustChain: (data) => api.post('/api/vault/trust/verify', data),
+  getTrustChains: () => api.get('/api/vault/trust/chains'),
+  // Secrets management
+  listSecrets: () => api.get('/api/vault/secrets'),
+  storeSecret: (name, value) => api.post('/api/vault/secrets', { name, value }),
+  getSecret: (name) => api.get(`/api/vault/secrets/${name}`),
+  deleteSecret: (name) => api.delete(`/api/vault/secrets/${name}`),
+};
+
+// Services API
+export const servicesAPI = {
+  getAllStatus: () => api.get('/api/services/status'),
+  testAllConnectivity: () => api.get('/api/services/connectivity'),
+  startService: (serviceName) => api.post(`/api/services/bus/services/${serviceName}/start`),
+  stopService: (serviceName) => api.post(`/api/services/bus/services/${serviceName}/stop`),
+  restartService: (serviceName) => api.post(`/api/services/bus/services/${serviceName}/restart`),
+};
+
+// Health check
+export const healthAPI = {
+  check: () => api.get('/health'),
+};
+
+// Monitoring API
+export const monitoringAPI = {
+  getBackendLogs: (lines = 100) => api.get('/api/logs', { params: { lines } }),
+  getHealthHistory: () => api.get('/api/health/history'),
+};
+
+// Container Management API
+export const containerAPI = {
+  // Containers
+  listContainers: () => api.get('/api/containers'),
+  startContainer: (name) => api.post(`/api/containers/${name}/start`),
+  stopContainer: (name) => api.post(`/api/containers/${name}/stop`),
+  restartContainer: (name) => api.post(`/api/containers/${name}/restart`),
+  getContainerLogs: (name, tail = 100) => api.get(`/api/containers/${name}/logs`, { params: { tail } }),
+  getContainerStats: (name) => api.get(`/api/containers/${name}/stats`),
+  createContainer: (data) => api.post('/api/containers', data), // data may include 'secrets' array
+  removeContainer: (name, force = false) => api.delete(`/api/containers/${name}`, { params: { force } }),
+  // Images
+  listImages: () => api.get('/api/images'),
+  pullImage: (image) => api.post('/api/images/pull', { image }),
+  removeImage: (image, force = false) => api.delete(`/api/images/${image}`, { params: { force } }),
+  // Volumes
+  listVolumes: () => api.get('/api/volumes'),
+  createVolume: (name) => api.post('/api/volumes', { name }),
+  removeVolume: (name, force = false) => api.delete(`/api/volumes/${name}`, { params: { force } }),
+};
+
 export default api;