Merge pull request #90 from ipnet-mesh/feat/feature-flags

Add feature flags to control web dashboard page visibility

Author: jinglemansweep

.env.example

@@ -213,6 +213,20 @@ NETWORK_RADIO_CONFIG=
 # If not set, a default welcome message is shown
 NETWORK_WELCOME_TEXT=
 
+# -------------------
+# Feature Flags
+# -------------------
+# Control which pages are visible in the web dashboard
+# Set to false to completely hide a page (nav, routes, sitemap, robots.txt)
+
+# FEATURE_DASHBOARD=true
+# FEATURE_NODES=true
+# FEATURE_ADVERTISEMENTS=true
+# FEATURE_MESSAGES=true
+# FEATURE_MAP=true
+# FEATURE_MEMBERS=true
+# FEATURE_PAGES=true
+
 # -------------------
 # Contact Information
 # -------------------

AGENTS.md

@@ -493,6 +493,7 @@ Key variables:
 - `API_READ_KEY`, `API_ADMIN_KEY` - API authentication keys
 - `WEB_ADMIN_ENABLED` - Enable admin interface at /a/ (default: `false`, requires auth proxy)
 - `TZ` - Timezone for web dashboard date/time display (default: `UTC`, e.g., `America/New_York`, `Europe/London`)
+- `FEATURE_DASHBOARD`, `FEATURE_NODES`, `FEATURE_ADVERTISEMENTS`, `FEATURE_MESSAGES`, `FEATURE_MAP`, `FEATURE_MEMBERS`, `FEATURE_PAGES` - Feature flags to enable/disable specific web dashboard pages (default: all `true`). Dependencies: Dashboard auto-disables when all of Nodes/Advertisements/Messages are disabled. Map auto-disables when Nodes is disabled.
 - `LOG_LEVEL` - Logging verbosity
 
 The database defaults to `sqlite:///{DATA_HOME}/collector/meshcore.db` and does not typically need to be configured.

README.md

@@ -341,6 +341,22 @@ The collector automatically cleans up old event data and inactive nodes:
 | `NETWORK_CONTACT_GITHUB` | *(none)* | GitHub repository URL |
 | `CONTENT_HOME` | `./content` | Directory containing custom content (pages/, media/) |
 
+#### Feature Flags
+
+Control which pages are visible in the web dashboard. Disabled features are fully hidden: removed from navigation, return 404 on their routes, and excluded from sitemap/robots.txt.
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `FEATURE_DASHBOARD` | `true` | Enable the `/dashboard` page |
+| `FEATURE_NODES` | `true` | Enable the `/nodes` pages (list, detail, short links) |
+| `FEATURE_ADVERTISEMENTS` | `true` | Enable the `/advertisements` page |
+| `FEATURE_MESSAGES` | `true` | Enable the `/messages` page |
+| `FEATURE_MAP` | `true` | Enable the `/map` page and `/map/data` endpoint |
+| `FEATURE_MEMBERS` | `true` | Enable the `/members` page |
+| `FEATURE_PAGES` | `true` | Enable custom markdown pages |
+
+**Dependencies:** Dashboard auto-disables when all of Nodes/Advertisements/Messages are disabled. Map auto-disables when Nodes is disabled.
+
 ### Custom Content
 
 The web dashboard supports custom content including markdown pages and media files. Content is organized in subdirectories:

docker-compose.yml

@@ -263,6 +263,14 @@ services:
       - NETWORK_WELCOME_TEXT=${NETWORK_WELCOME_TEXT:-}
       - CONTENT_HOME=/content
       - TZ=${TZ:-UTC}
+      # Feature flags (set to false to disable specific pages)
+      - FEATURE_DASHBOARD=${FEATURE_DASHBOARD:-true}
+      - FEATURE_NODES=${FEATURE_NODES:-true}
+      - FEATURE_ADVERTISEMENTS=${FEATURE_ADVERTISEMENTS:-true}
+      - FEATURE_MESSAGES=${FEATURE_MESSAGES:-true}
+      - FEATURE_MAP=${FEATURE_MAP:-true}
+      - FEATURE_MEMBERS=${FEATURE_MEMBERS:-true}
+      - FEATURE_PAGES=${FEATURE_PAGES:-true}
     command: ["web"]
     healthcheck:
       test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health')"]

src/meshcore_hub/common/config.py

@@ -301,12 +301,52 @@ class WebSettings(CommonSettings):
         default=None, description="Welcome text for homepage"
     )
 
+    # Feature flags (control which pages are visible in the web dashboard)
+    feature_dashboard: bool = Field(
+        default=True, description="Enable the /dashboard page"
+    )
+    feature_nodes: bool = Field(default=True, description="Enable the /nodes pages")
+    feature_advertisements: bool = Field(
+        default=True, description="Enable the /advertisements page"
+    )
+    feature_messages: bool = Field(
+        default=True, description="Enable the /messages page"
+    )
+    feature_map: bool = Field(
+        default=True, description="Enable the /map page and /map/data endpoint"
+    )
+    feature_members: bool = Field(default=True, description="Enable the /members page")
+    feature_pages: bool = Field(
+        default=True, description="Enable custom markdown pages"
+    )
+
     # Content directory (contains pages/ and media/ subdirectories)
     content_home: Optional[str] = Field(
         default=None,
         description="Directory containing custom content (pages/, media/) (default: ./content)",
     )
 
+    @property
+    def features(self) -> dict[str, bool]:
+        """Get feature flags as a dictionary.
+
+        Automatic dependencies:
+        - Dashboard requires at least one of nodes/advertisements/messages.
+        - Map requires nodes (map displays node locations).
+        """
+        has_dashboard_content = (
+            self.feature_nodes or self.feature_advertisements or self.feature_messages
+        )
+        return {
+            "dashboard": self.feature_dashboard and has_dashboard_content,
+            "nodes": self.feature_nodes,
+            "advertisements": self.feature_advertisements,
+            "messages": self.feature_messages,
+            "map": self.feature_map and self.feature_nodes,
+            "members": self.feature_members,
+            "pages": self.feature_pages,
+        }
+
     @property
     def effective_content_home(self) -> str:
         """Get the effective content home directory."""

src/meshcore_hub/web/app.py

@@ -68,23 +68,32 @@ def _build_config_json(app: FastAPI, request: Request) -> str:
     radio_config_dict = None
     if radio_config:
         radio_config_dict = {
+            "profile": radio_config.profile,
             "frequency": radio_config.frequency,
             "bandwidth": radio_config.bandwidth,
             "spreading_factor": radio_config.spreading_factor,
             "coding_rate": radio_config.coding_rate,
+            "tx_power": radio_config.tx_power,
         }
 
-    # Get custom pages for navigation
+    # Get feature flags
+    features = app.state.features
+
+    # Get custom pages for navigation (empty when pages feature is disabled)
     page_loader = app.state.page_loader
-    custom_pages = [
-        {
-            "slug": p.slug,
-            "title": p.title,
-            "url": p.url,
-            "menu_order": p.menu_order,
-        }
-        for p in page_loader.get_menu_pages()
-    ]
+    custom_pages = (
+        [
+            {
+                "slug": p.slug,
+                "title": p.title,
+                "url": p.url,
+                "menu_order": p.menu_order,
+            }
+            for p in page_loader.get_menu_pages()
+        ]
+        if features.get("pages", True)
+        else []
+    )
 
     config = {
         "network_name": app.state.network_name,
@@ -97,6 +106,7 @@ def _build_config_json(app: FastAPI, request: Request) -> str:
         "network_contact_youtube": app.state.network_contact_youtube,
         "network_welcome_text": app.state.network_welcome_text,
         "admin_enabled": app.state.admin_enabled,
+        "features": features,
         "custom_pages": custom_pages,
         "logo_url": app.state.logo_url,
         "version": __version__,
@@ -121,6 +131,7 @@ def create_app(
     network_contact_github: str | None = None,
     network_contact_youtube: str | None = None,
     network_welcome_text: str | None = None,
+    features: dict[str, bool] | None = None,
 ) -> FastAPI:
     """Create and configure the web dashboard application.
 
@@ -140,6 +151,7 @@ def create_app(
         network_contact_github: GitHub repository URL
         network_contact_youtube: YouTube channel URL
         network_welcome_text: Welcome text for homepage
+        features: Feature flags dict (default: all enabled from settings)
 
     Returns:
         Configured FastAPI application
@@ -189,6 +201,24 @@ def create_app(
         network_welcome_text or settings.network_welcome_text
     )
 
+    # Store feature flags with automatic dependencies:
+    # - Dashboard requires at least one of nodes/advertisements/messages
+    # - Map requires nodes (map displays node locations)
+    effective_features = features if features is not None else settings.features
+    overrides: dict[str, bool] = {}
+    has_dashboard_content = (
+        effective_features.get("nodes", True)
+        or effective_features.get("advertisements", True)
+        or effective_features.get("messages", True)
+    )
+    if not has_dashboard_content:
+        overrides["dashboard"] = False
+    if not effective_features.get("nodes", True):
+        overrides["map"] = False
+    if overrides:
+        effective_features = {**effective_features, **overrides}
+    app.state.features = effective_features
+
     # Set up templates (for SPA shell only)
     templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
     templates.env.trim_blocks = True
@@ -309,6 +339,8 @@ async def api_proxy(request: Request, path: str) -> Response:
     @app.get("/map/data", tags=["Map"])
     async def map_data(request: Request) -> JSONResponse:
         """Return node location data as JSON for the map."""
+        if not request.app.state.features.get("map", True):
+            return JSONResponse({"detail": "Map feature is disabled"}, status_code=404)
         nodes_with_location: list[dict[str, Any]] = []
         members_list: list[dict[str, Any]] = []
         members_by_id: dict[str, dict[str, Any]] = {}
@@ -448,6 +480,10 @@ async def map_data(request: Request) -> JSONResponse:
     @app.get("/spa/pages/{slug}", tags=["SPA"])
     async def get_custom_page(request: Request, slug: str) -> JSONResponse:
         """Get a custom page by slug."""
+        if not request.app.state.features.get("pages", True):
+            return JSONResponse(
+                {"detail": "Pages feature is disabled"}, status_code=404
+            )
         page_loader = request.app.state.page_loader
         page = page_loader.get_page(slug)
         if not page:
@@ -489,21 +525,57 @@ def _get_https_base_url(request: Request) -> str:
     async def robots_txt(request: Request) -> str:
         """Serve robots.txt."""
         base_url = _get_https_base_url(request)
-        return f"User-agent: *\nDisallow:\n\nSitemap: {base_url}/sitemap.xml\n"
+        features = request.app.state.features
+
+        # Always disallow message and node detail pages
+        disallow_lines = [
+            "Disallow: /messages",
+            "Disallow: /nodes/",
+        ]
+
+        # Add disallow for disabled features
+        feature_paths = {
+            "dashboard": "/dashboard",
+            "nodes": "/nodes",
+            "advertisements": "/advertisements",
+            "map": "/map",
+            "members": "/members",
+            "pages": "/pages",
+        }
+        for feature, path in feature_paths.items():
+            if not features.get(feature, True):
+                line = f"Disallow: {path}"
+                if line not in disallow_lines:
+                    disallow_lines.append(line)
+
+        disallow_block = "\n".join(disallow_lines)
+        return (
+            f"User-agent: *\n"
+            f"{disallow_block}\n"
+            f"\n"
+            f"Sitemap: {base_url}/sitemap.xml\n"
+        )
 
     @app.get("/sitemap.xml")
     async def sitemap_xml(request: Request) -> Response:
-        """Generate dynamic sitemap including all node pages."""
+        """Generate dynamic sitemap."""
         base_url = _get_https_base_url(request)
+        features = request.app.state.features
+
+        # Home is always included; other pages depend on feature flags
+        all_static_pages = [
+            ("", "daily", "1.0", None),
+            ("/dashboard", "hourly", "0.9", "dashboard"),
+            ("/nodes", "hourly", "0.9", "nodes"),
+            ("/advertisements", "hourly", "0.8", "advertisements"),
+            ("/map", "daily", "0.7", "map"),
+            ("/members", "weekly", "0.6", "members"),
+        ]
 
         static_pages = [
-            ("", "daily", "1.0"),
-            ("/dashboard", "hourly", "0.9"),
-            ("/nodes", "hourly", "0.9"),
-            ("/advertisements", "hourly", "0.8"),
-            ("/messages", "hourly", "0.8"),
-            ("/map", "daily", "0.7"),
-            ("/members", "weekly", "0.6"),
+            (path, freq, prio)
+            for path, freq, prio, feature in all_static_pages
+            if feature is None or features.get(feature, True)
         ]
 
         urls = []
@@ -516,34 +588,16 @@ async def sitemap_xml(request: Request) -> Response:
                 f"  </url>"
             )
 
-        try:
-            response = await request.app.state.http_client.get(
-                "/api/v1/nodes", params={"limit": 500, "role": "infra"}
-            )
-            if response.status_code == 200:
-                nodes = response.json().get("items", [])
-                for node in nodes:
-                    public_key = node.get("public_key")
-                    if public_key:
-                        urls.append(
-                            f"  <url>\n"
-                            f"    <loc>{base_url}/nodes/{public_key[:8]}</loc>\n"
-                            f"    <changefreq>daily</changefreq>\n"
-                            f"    <priority>0.5</priority>\n"
-                            f"  </url>"
-                        )
-        except Exception as e:
-            logger.warning(f"Failed to fetch nodes for sitemap: {e}")
-
-        page_loader = request.app.state.page_loader
-        for page in page_loader.get_menu_pages():
-            urls.append(
-                f"  <url>\n"
-                f"    <loc>{base_url}{page.url}</loc>\n"
-                f"    <changefreq>weekly</changefreq>\n"
-                f"    <priority>0.6</priority>\n"
-                f"  </url>"
-            )
+        if features.get("pages", True):
+            page_loader = request.app.state.page_loader
+            for page in page_loader.get_menu_pages():
+                urls.append(
+                    f"  <url>\n"
+                    f"    <loc>{base_url}{page.url}</loc>\n"
+                    f"    <changefreq>weekly</changefreq>\n"
+                    f"    <priority>0.6</priority>\n"
+                    f"  </url>"
+                )
 
         xml = (
             '<?xml version="1.0" encoding="UTF-8"?>\n'
@@ -559,8 +613,11 @@ async def sitemap_xml(request: Request) -> Response:
     async def spa_catchall(request: Request, path: str = "") -> HTMLResponse:
         """Serve the SPA shell for all non-API routes."""
         templates_inst: Jinja2Templates = request.app.state.templates
+        features = request.app.state.features
         page_loader = request.app.state.page_loader
-        custom_pages = page_loader.get_menu_pages()
+        custom_pages = (
+            page_loader.get_menu_pages() if features.get("pages", True) else []
+        )
 
         config_json = _build_config_json(request.app, request)
 
@@ -577,6 +634,7 @@ async def spa_catchall(request: Request, path: str = "") -> HTMLResponse:
                 "network_contact_youtube": request.app.state.network_contact_youtube,
                 "network_welcome_text": request.app.state.network_welcome_text,
                 "admin_enabled": request.app.state.admin_enabled,
+                "features": features,
                 "custom_pages": custom_pages,
                 "logo_url": request.app.state.logo_url,
                 "version": __version__,

src/meshcore_hub/web/cli.py

@@ -183,6 +183,11 @@ def web(
     if effective_city and effective_country:
         click.echo(f"Location: {effective_city}, {effective_country}")
     click.echo(f"Reload mode: {reload}")
+    disabled_features = [
+        name for name, enabled in settings.features.items() if not enabled
+    ]
+    if disabled_features:
+        click.echo(f"Disabled features: {', '.join(disabled_features)}")
     click.echo("=" * 50)
 
     if reload: