feat: Add standalone Android app with embedded Python backend via Chaquopy

- Integrate Chaquopy Gradle plugin to embed Python 3.8 runtime on Android
- Add MeshSyncService foreground service to run Python backend in background
- Configure pip packages: FastAPI, Uvicorn, Pydantic v1, aiosqlite, PyNaCl
- Create android_main.py entry point for Chaquopy integration
- Add Gradle task to copy DTN and ValueFlows backend source at build time
- Configure proper task dependencies for Gradle 8.x strict validation
- Add Android permissions for WiFi Direct, Bluetooth, and foreground service
- Add node configuration page and guards for first-time setup
- APK includes Python runtime for arm64-v8a, armeabi-v7a, x86, x86_64

The app runs completely offline with FastAPI backends on localhost:8000/8001.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: lizTheDeveloper

app/api/node_config.py

@@ -0,0 +1,102 @@
+"""
+Node Configuration API
+
+Handles initial node setup and configuration management.
+"""
+
+from fastapi import APIRouter, HTTPException
+from app.models.node_config import NodeConfig, NodeConfigUpdate
+from app.services.node_config_service import get_node_config_service
+import structlog
+
+logger = structlog.get_logger()
+
+router = APIRouter(prefix="/node", tags=["node"])
+
+
+@router.get("/config")
+async def get_node_config():
+    """
+    Get current node configuration.
+
+    Returns:
+        NodeConfig if configured, None if not yet configured
+    """
+    service = get_node_config_service()
+    config = service.get_config()
+
+    if not config:
+        return None
+
+    return config
+
+
+@router.get("/config/status")
+async def get_config_status():
+    """Check if node has been configured"""
+    service = get_node_config_service()
+    return {
+        "configured": service.is_configured()
+    }
+
+
+@router.post("/config")
+async def create_node_config(config: NodeConfig):
+    """
+    Create initial node configuration.
+
+    This should only be called once during first-run setup.
+
+    Raises:
+        400: If node is already configured
+        422: If validation fails
+    """
+    service = get_node_config_service()
+
+    try:
+        created_config = service.create_config(config)
+
+        logger.info(
+            "node_configured_via_api",
+            mesh_name=created_config.mesh_fqdn,
+            ai_enabled=created_config.enable_ai_inference,
+            bridge_enabled=created_config.enable_bridge_mode,
+        )
+
+        return created_config
+
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("config_creation_failed", error=str(e))
+        raise HTTPException(status_code=500, detail="Failed to create configuration")
+
+
+@router.put("/config")
+async def update_node_config(updates: NodeConfigUpdate):
+    """
+    Update node configuration.
+
+    Only provided fields will be updated.
+
+    Raises:
+        400: If node is not configured yet
+        422: If validation fails
+    """
+    service = get_node_config_service()
+
+    try:
+        updated_config = service.update_config(updates)
+
+        logger.info(
+            "node_config_updated_via_api",
+            mesh_name=updated_config.mesh_fqdn,
+        )
+
+        return updated_config
+
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error("config_update_failed", error=str(e))
+        raise HTTPException(status_code=500, detail="Failed to update configuration")

app/config.py

@@ -41,7 +41,7 @@ class Settings(BaseSettings):
 
     # CORS configuration
     allowed_origins: List[str] = Field(
-        default=["http://localhost:3000", "http://localhost:5173", "http://127.0.0.1:3000", "http://127.0.0.1:5173"],
+        default=["http://localhost:3000", "http://localhost:5173", "http://localhost:4444", "http://127.0.0.1:3000", "http://127.0.0.1:5173", "http://127.0.0.1:4444"],
         description="Allowed CORS origins"
     )
 

app/main.py

@@ -68,9 +68,14 @@
 from .api.fork_rights import router as fork_rights_router
 from .api.security_status import router as security_status_router
 from .api.mourning import router as mourning_router
+from .api.node_config import router as node_config_router
 from .services import TTLService, CryptoService, CacheService
+from .services.node_config_service import get_node_config_service
 from .middleware import CSRFMiddleware, PrometheusMetricsMiddleware, metrics_endpoint, init_metrics
 from .middleware.correlation_id import CorrelationIdMiddleware
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+from mesh_naming.mesh_dns import get_mesh_naming
 
 # Configure structured logging
 configure_logging(log_level=settings.log_level, json_logs=settings.json_logs)
@@ -144,6 +149,35 @@ async def lifespan(app: FastAPI):
     init_metrics(version="1.0.0", node_id=fingerprint)
     logger.info("Prometheus metrics initialized")
 
+    # Initialize mesh naming if node is configured
+    try:
+        node_config_service = get_node_config_service()
+        node_config = node_config_service.get_config()
+
+        if node_config:
+            # Initialize mesh naming with node config
+            mesh_naming = get_mesh_naming(
+                node_name=node_config.mesh_name,
+                community_name=node_config.community_name,
+            )
+
+            # Announce on the network if AI inference or bridge mode enabled
+            if node_config.enable_ai_inference or node_config.enable_bridge_mode:
+                mesh_naming.announce(
+                    dtn_port=settings.port,
+                    valueflows_port=8001,
+                    ai_port=8005,
+                )
+                logger.info(
+                    "mesh_announced",
+                    mesh_name=node_config.mesh_fqdn,
+                    ai_enabled=node_config.enable_ai_inference,
+                    bridge_enabled=node_config.enable_bridge_mode,
+                )
+    except Exception as e:
+        logger.warning("mesh_naming_initialization_failed", error=str(e))
+        # Continue startup even if mesh naming fails
+
     logger.info("DTN Bundle System started successfully")
     logger.info("=" * 60)
     logger.info(f"API available at http://{settings.host}:{settings.port}")
@@ -170,6 +204,15 @@ async def lifespan(app: FastAPI):
         await ttl_service.stop()
         logger.info("TTL service stopped")
 
+    # Shutdown mesh naming if active
+    try:
+        mesh_naming = get_mesh_naming()
+        if mesh_naming:
+            mesh_naming.shutdown()
+            logger.info("Mesh naming service stopped")
+    except:
+        pass
+
     # Close database connections
     logger.info("Closing database connections...")
     await close_db()
@@ -216,6 +259,8 @@ async def lifespan(app: FastAPI):
         "/openapi.json",
         "/health",
         "/node/info",
+        "/node/config",  # Node configuration must be accessible before users exist
+        "/node/config/status",
         "/auth/csrf-token",  # CSRF token endpoint must be exempt
         "/auth/register",  # Registration should be exempt
         "/auth/login",  # Login should be exempt
@@ -253,6 +298,7 @@ async def lifespan(app: FastAPI):
 app.include_router(fork_rights_router)
 app.include_router(security_status_router)
 app.include_router(mourning_router)
+app.include_router(node_config_router)
 
 
 @app.get("/")

app/models/node_config.py

@@ -0,0 +1,72 @@
+"""
+Node Configuration Model
+
+Stores configuration for this specific node/device.
+This is set once during initial setup, before any users log in.
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime
+
+
+class NodeConfig(BaseModel):
+    """Configuration for this mesh node"""
+
+    # Identity
+    mesh_name: str = Field(
+        ...,
+        description="Node name on .multiversemesh (e.g., 'alice', 'food-coop')"
+    )
+    community_name: Optional[str] = Field(
+        None,
+        description="Community subdomain (e.g., 'mycommunity' → alice.mycommunity.multiversemesh)"
+    )
+    node_description: Optional[str] = Field(
+        None,
+        description="What is this node for? (e.g., 'Personal device', 'Community hub')"
+    )
+
+    # Services
+    enable_ai_inference: bool = Field(
+        default=False,
+        description="Share AI compute with the mesh"
+    )
+    enable_bridge_mode: bool = Field(
+        default=False,
+        description="Act as bridge between mesh islands"
+    )
+
+    # Contact
+    admin_contact: Optional[str] = Field(
+        None,
+        description="Contact info for node operator (optional)"
+    )
+
+    # Metadata
+    configured_at: datetime = Field(
+        default_factory=datetime.utcnow,
+        description="When this node was configured"
+    )
+    node_id: Optional[str] = Field(
+        None,
+        description="Auto-generated unique node ID"
+    )
+
+    @property
+    def mesh_fqdn(self) -> str:
+        """Get full mesh name"""
+        if self.community_name:
+            return f"{self.mesh_name}.{self.community_name}.multiversemesh"
+        return f"{self.mesh_name}.multiversemesh"
+
+
+class NodeConfigUpdate(BaseModel):
+    """Update node configuration"""
+
+    mesh_name: Optional[str] = None
+    community_name: Optional[str] = None
+    node_description: Optional[str] = None
+    enable_ai_inference: Optional[bool] = None
+    enable_bridge_mode: Optional[bool] = None
+    admin_contact: Optional[str] = None