@router.get("/api/network/export")
async def export_network(
    include_password_hashes: bool = False,
    include_sensitive_config: bool = False,
    notes: Optional[str] = None,
) -> StreamingResponse:
    """
    Export current network configuration as .zip file.

    Returns:
        StreamingResponse with .zip file content
    """

@router.post("/api/network/import/validate")
async def validate_import(
    file: UploadFile,
) -> ImportValidationResult:
    """
    Validate uploaded .zip file before import.

    Returns:
        ImportValidationResult with validation status, warnings, preview
    """

@router.post("/api/network/import/apply")
async def apply_import(
    file: UploadFile,
    mode: ImportMode,  # "create_new" or "overwrite"
    new_name: Optional[str] = None,  # Required if mode is "create_new"
) -> ImportResult:
    """
    Apply imported network configuration and restart network.

    Returns:
        ImportResult with status and restart result
    """

class ImportMode(str, Enum):
    CREATE_NEW = "create_new"
    OVERWRITE = "overwrite"

class ImportValidationResult(BaseModel):
    valid: bool
    errors: List[str]
    warnings: List[str]
    preview: ImportPreview

class ImportPreview(BaseModel):
    network_name: str
    network_mode: str
    mods: List[str]
    agent_groups: List[str]
    transports: List[str]
    export_timestamp: Optional[datetime]
    export_notes: Optional[str]
    source_version: Optional[str]

class ImportResult(BaseModel):
    success: bool
    message: str
    restarted: bool              # True if network was successfully restarted
    restart_error: Optional[str] # Error message if restart failed
    network_name: str

class ExportManifest(BaseModel):
    version: str = "1.0"
    export_timestamp: datetime
    source_network: str
    source_version: str
    openagents_version: str
    notes: Optional[str]
    includes_password_hashes: bool
    includes_sensitive_config: bool

# src/openagents/utils/network_export.py

import zipfile
import yaml
from io import BytesIO
from datetime import datetime

class NetworkExporter:
    def __init__(self, network: Network):
        self.network = network

    def export_to_zip(
        self,
        include_password_hashes: bool = False,
        include_sensitive_config: bool = False,
        notes: Optional[str] = None,
    ) -> BytesIO:
        """Export network configuration to zip archive."""

        buffer = BytesIO()

        with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
            # Add manifest
            manifest = self._create_manifest(notes, include_password_hashes, include_sensitive_config)
            zf.writestr('manifest.json', json.dumps(manifest, default=str, indent=2))

            # Add network config
            network_config = self._sanitize_config(
                self.network.config,
                include_password_hashes,
                include_sensitive_config,
            )
            zf.writestr('network.yaml', yaml.dump(network_config, default_flow_style=False))

            # Add network profile if exists
            if self.network.profile:
                zf.writestr('network_profile.yaml', yaml.dump(self.network.profile.dict()))

            # Add mod configs
            for mod in self.network.mods:
                if mod.has_exportable_config:
                    zf.writestr(f'mods/{mod.name}.yaml', yaml.dump(mod.export_config()))

        buffer.seek(0)
        return buffer

    def _sanitize_config(self, config: NetworkConfig, include_hashes: bool, include_sensitive: bool) -> dict:
        """Remove sensitive data based on options."""
        data = config.dict()

        if not include_hashes:
            for group in data.get('agent_groups', {}).values():
                group.pop('password_hash', None)

        if not include_sensitive:
            # Remove API keys, secrets, etc. from mod configs
            for mod in data.get('mods', []):
                self._strip_sensitive_fields(mod.get('config', {}))

        return data

# src/openagents/utils/network_import.py

class NetworkImporter:
    REQUIRED_FILES = ['manifest.json', 'network.yaml']

    def validate(self, zip_file: BytesIO) -> ImportValidationResult:
        """Validate zip archive before import."""
        errors = []
        warnings = []

        try:
            with zipfile.ZipFile(zip_file, 'r') as zf:
                # Check required files
                files = zf.namelist()
                for required in self.REQUIRED_FILES:
                    if required not in files:
                        errors.append(f"Missing required file: {required}")

                if errors:
                    return ImportValidationResult(valid=False, errors=errors, warnings=[], preview=None)

                # Parse and validate manifest
                manifest = json.loads(zf.read('manifest.json'))

                # Parse and validate network config
                network_yaml = yaml.safe_load(zf.read('network.yaml'))

                # Check mod compatibility
                for mod in network_yaml.get('network', {}).get('mods', []):
                    if not self._is_mod_available(mod['name']):
                        warnings.append(f"Mod not installed: {mod['name']}")

                # Build preview
                preview = self._build_preview(manifest, network_yaml)

                return ImportValidationResult(
                    valid=True,
                    errors=[],
                    warnings=warnings,
                    preview=preview,
                )

        except Exception as e:
            return ImportValidationResult(
                valid=False,
                errors=[f"Invalid archive: {str(e)}"],
                warnings=[],
                preview=None,
            )

    async def apply(
        self,
        zip_file: BytesIO,
        mode: ImportMode,
        network: Network,
        new_name: Optional[str] = None,
    ) -> ImportResult:
        """Apply imported configuration and restart network."""

        with zipfile.ZipFile(zip_file, 'r') as zf:
            network_yaml = yaml.safe_load(zf.read('network.yaml'))

            if mode == ImportMode.CREATE_NEW:
                network_yaml['network']['name'] = new_name
                network_yaml['network']['node_id'] = f"{new_name.lower().replace(' ', '-')}-1"

            # Write to config file
            config_path = self._get_config_path()
            with open(config_path, 'w') as f:
                yaml.dump(network_yaml, f, default_flow_style=False)

            # Extract mod configs
            for name in zf.namelist():
                if name.startswith('mods/') and name.endswith('.yaml'):
                    mod_config = yaml.safe_load(zf.read(name))
                    self._apply_mod_config(name, mod_config)

        # Parse new config and restart network
        new_config = NetworkConfig(**network_yaml['network'])

        try:
            restart_success = await network.restart(new_config)
            return ImportResult(
                success=True,
                message="Network configuration imported and restarted successfully",
                restarted=restart_success,
                restart_error=None if restart_success else "Restart returned False",
                network_name=network_yaml['network']['name'],
            )
        except Exception as e:
            return ImportResult(
                success=True,  # Config was applied, but restart failed
                message="Configuration imported but restart failed",
                restarted=False,
                restart_error=str(e),
                network_name=network_yaml['network']['name'],
            )

# Add to src/openagents/core/network.py

class Network:
    # ... existing methods ...

    async def restart(self, new_config: Optional[NetworkConfig] = None) -> bool:
        """Restart network with optional new configuration.

        Performs a graceful shutdown followed by re-initialization.
        Connected agents will be disconnected and need to reconnect.

        Args:
            new_config: New configuration to apply. If None, reloads from config file.

        Returns:
            bool: True if restart successful
        """
        logger.info(f"Restarting network '{self.network_name}'...")

        # 1. Graceful shutdown - disconnect all agents, stop mods
        shutdown_success = await self.shutdown()
        if not shutdown_success:
            logger.error("Failed to shutdown network during restart")
            return False

        # 2. Apply new config if provided
        if new_config:
            self.config = new_config
            self.network_name = new_config.name
        else:
            # Reload from config file
            self.config = self._load_config_from_file()
            self.network_name = self.config.name

        # 3. Re-initialize with new/reloaded config
        init_success = await self.initialize()
        if not init_success:
            logger.error("Failed to initialize network during restart")
            return False

        logger.info(f"Network '{self.network_name}' restarted successfully")
        return True

    def _load_config_from_file(self) -> NetworkConfig:
        """Reload configuration from the config file."""
        import yaml
        with open(self.config_path, 'r') as f:
            config_data = yaml.safe_load(f)
        return NetworkConfig(**config_data.get('network', config_data))

from openagents.utils.network_export import NetworkExporter

exporter = NetworkExporter(network)
zip_buffer = exporter.export_to_zip(
    include_password_hashes=False,
    notes="Backup before v2 migration"
)

with open('network_backup.zip', 'wb') as f:
    f.write(zip_buffer.read())